4.9 A Non-PCP Approach to Succinct Quantum-Safe ZK

The high-level idea of [BLN+20] is twofold. On one hand, it upgrades the amortized linear-relation proof for Ajtai commitments from [BBC+18a] into a levelled SIS commitment, making the commitment object recursively compressing. On the other hand, it gives a lattice analogue of the Bulletproofs folding argument [BBB+18]. Concretely, we have:

  • •

    levelled SIS commitments, with communication

    O⁢(N1/(d+1)⋅(d3⁢λ⁢log2⁡N+d⁢λ2))

    for d levels, and hence 𝗉𝗈𝗅𝗒𝗅𝗈𝗀⁢(N) communication on d+1=log⁡N;

  • •

    a lattice analogue of the Bulletproofs folding argument [BBB+18], with smaller polylogarithmic proof size but much larger extraction slack in knowledge soundness.

N is the number of committed secret values. Recall the note section 4.8 on [BBC+18a] that the one-level construction has O~⁢(N) communication after balancing the number of commitments and the opening proof size after amortization. We begin by showing how [BLN+20] reduces the communication via a two-level commitment instantiation. As in the previous lattice argument note, we suppress the zero-knowledge layer: the commitment is hiding, and the proof is made zero-knowledge by Gaussian masking with rejection sampling in the Fiat-Shamir-with-aborts style.

Two-Level Commitment Map.

The levelling idea starts by committing to commitments. On message 𝐒∈ℤm1⁢m2×m3, commitment keys 𝐀1∈ℤq1n×n⁢m1, 𝐀2∈ℤq2n×m2, and q1>q2. The top commitment is

𝐓=𝐀1⋅((𝐈m1⊗𝐀2)⋅𝐒modq2)modq1.

This is SIS-commitment-like at each level: the lower level compresses blocks of 𝐒, and the upper level compresses the lower-level commitments. At this point this is just the commitment map: an honest opening is a matrix 𝐒 whose image under the above map is 𝐓, and 𝐒 is short.

General Levelled Commitments.

For d levels, let N=∏i∈[1,d+1]mi, m0=1, and q1>⋯>qd. The bottom matrix is 𝐀d∈ℤqdn×md, and for i<d, 𝐀i∈ℤqin×n⁢mi. Define Mi,j=mi⁢⋯⁢mj and Mi=M1,i, and define recursively

Fi,j⁢(𝐒)={𝐀i⁢𝐒modqi,i=j,Fi,j−1⁢((𝐈Mi,j−1⊗𝐀j)⋅𝐒modqj),i<j.

The statement is 𝐓←F1,d⁢(𝐒), where d is the number of levels.

Folding Operations.

Similar to the challenges in section 4.8, the challenges are matrices over the challenge set 𝒞 the same as the one in section 4.8, with shape 𝐂1←r𝒞md+1×λ, and 𝐂i←r𝒞mi−1⁢λ×λ for i∈[2,d].

For a matrix 𝐙 whose rows are split into mi consecutive blocks 𝐙1,…,𝐙mi of equal size, define the block transpose

𝖡𝖳i⁢(𝐙)=[𝐙1⁢∣…∣⁢𝐙mi].

We also use the recursive folding map 𝖥𝗈𝗅𝖽i from [BLN+20]. The base case is

𝖥𝗈𝗅𝖽0⁢(𝐔1;𝐂1)=𝐔1⁢𝐂1.

For i>0, split the input tuple (𝐔1,…,𝐔Mi) into mi consecutive subtuples, such that for j∈[1,mi],

𝐔‾j=(𝐔(j−1)⁢Mi−1+1,…,𝐔j⁢Mi−1).

Then

𝖥𝗈𝗅𝖽i⁢(𝐔1,…,𝐔Mi;𝐂1,…,𝐂i+1)=𝖡𝖳i⁢(𝖥𝗈𝗅𝖽i−1⁢(𝐔‾1;𝐂1,…,𝐂i)⋮𝖥𝗈𝗅𝖽i−1⁢(𝐔‾mi;𝐂1,…,𝐂i))⁢𝐂i+1.
Lemma 4.9.1 (Fold properties [BLN+20]).

Fix i and {𝐔j}j∈[1,Mi] with compatible dimensions. For challenges {𝐂j}j∈[1,i+1] with the shapes above:

  • •

    there exist matrices {𝐃i}i∈[1,Mt] with ‖𝐃i‖∞≤λi such that

    𝖥𝗈𝗅𝖽i⁢(𝐔1,…,𝐔Mi;𝐂1,…,𝐂i+1)=∑t∈[1,Mi]𝐔t⁢𝐃t;
  • •

    for every compatible matrix 𝐁,

    𝐁⋅𝖥𝗈𝗅𝖽i⁢(𝐔1,…,𝐔Mi;𝐂1,…,𝐂i+1)=𝖥𝗈𝗅𝖽i⁢(𝐁𝐔1,…,𝐁𝐔Mi;𝐂1,…,𝐂i+1);
  • •

    if each 𝐔t is vertically split as 𝐔t=[𝐔t,1𝖳⁢∣⋯∣⁢𝐔t,r𝖳]𝖳, then

    𝖥𝗈𝗅𝖽i⁢(𝐔1,…,𝐔Mi;𝐂1,…,𝐂i+1)=[𝖥𝗈𝗅𝖽i⁢(𝐔1,1,…,𝐔Mi,1;𝐂1,…,𝐂i+1)⋮𝖥𝗈𝗅𝖽i⁢(𝐔1,r,…,𝐔Mi,r;𝐂1,…,𝐂i+1)].
Proof.

We prove all three parts by induction on i. For i=0, the definition gives 𝖥𝗈𝗅𝖽0⁢(𝐔1;𝐂1)=𝐔1⁢𝐂1. Thus the first part holds with 𝐃1=𝐂1, and the second and third parts are immediate.

Assume the claims hold for i−1. Split (𝐔1,…,𝐔Mi) into subtuples 𝐔‾1,…,𝐔‾mi as was defined 𝖥𝗈𝗅𝖽i, and write

𝐖j=𝖥𝗈𝗅𝖽i−1⁢(𝐔‾j;𝐂1,…,𝐂i).

Also split the rows of 𝐂i+1 into mi blocks 𝐂i+1(1),…,𝐂i+1(mi), each of shape λ×λ. Then

𝖥𝗈𝗅𝖽i⁢(𝐔1,…,𝐔Mi;𝐂1,…,𝐂i+1)=∑j∈[1,mi]𝐖j⁢𝐂i+1(j).

By induction, each 𝐖j is a bounded linear combination of the matrices in 𝐔‾j. Multiplying by 𝐂i+1(j) gives coefficient matrices whose ℓ∞ norm grows by at most a factor λ, since challenge entries have coefficient norm at most 1. Hence the new coefficients 𝐃t satisfy ‖𝐃t‖∞≤λi, proving the first part.

For the second part, using the induction on each subtuple,

𝐁𝐖j=𝖥𝗈𝗅𝖽i−1⁢(𝐁⁢𝐔‾j;𝐂1,…,𝐂i).

Therefore multiplying 𝖥𝗈𝗅𝖽i by 𝐁 on the left is the same as replacing every input 𝐔t by 𝐁𝐔t before the recursive fold.

For the third part, since each 𝐔t splits into r vertical blocks, then by induction, each 𝐖j splits into the corresponding folded block. Horizontal concatenation followed by multiplication by 𝐂i+1 preserves this vertical block decomposition, so the ath vertical output block is

𝖥𝗈𝗅𝖽i⁢(𝐔1,a,…,𝐔Mi,a;𝐂1,…,𝐂i+1).

This proves the stacking identity and completes the induction. ∎

To describe the prover’s messages that are folded, we write 𝐒 as 𝐒i1,…,id−1 for (i1,…,id−1)∈[1,m1]×…×[1,md−1], as a leaf of md×md+1 elements. In the levelled commitment perspective, the intermediate commitments are viewed as internal nodes of the tree, and for k∈[1,d−2], define intermediate vertices recursively by

𝐒i1,…,ik=(𝐈mk+1⊗𝐀k+2)⁢[𝐒i1,…,ik,1⋮𝐒i1,…,ik,mk+1]modqk+2,

of shape n⁢mk+1×md+1 elements. Finally,

𝐒∅=(𝐈m1⊗𝐀2)⁢[𝐒1⋮𝐒m1]modq2,

with shape n⁢m1×md+1 elements, so 𝐀1⁢𝐒∅≡𝐓modq1. For the ith response, the prover uses the tuple

𝐕i={𝐒∅,i=1,(𝐒𝜶)𝜶∈[1,m1]×⋯×[1,mi−1],i>1,

where 𝐕i is ordered with the first coordinate varying fastest. This is the protocol order used by 𝖥𝗈𝗅𝖽i−1; the recursive definition of each intermediate vertex still stacks its children under a fixed prefix.

Amortized Levelled Proof.

We now show the 0-1 compression invariant 𝐀𝐒𝐂≡𝐓𝐂modq from [BBC+18a] in the levelled setting of [BLN+20]. The point of lemma 4.9.1 is twofold here: the vertical decomposition lets us treat a folded intermediate commitment as the stack of folded child commitments, while the left multiplication property lets us pull out the next SIS matrix 𝐀i+1. Then 𝖡𝖳i only rearranges this vertical stack into the horizontal sibling blocks expected by the next challenge. With this abstraction, we show by induction over the levels of the commitment tree.

  • •

    At the root, 𝐀1⁢𝐒∅≡𝐓modq1, and therefore we have 𝐀1⁢𝐙1≡𝐓𝐂1modq1.

  • •

    For the inductive step, write 𝐕i+1=(𝐕i,1,…,𝐕i,mi), where 𝐕i,j is the tuple of the jth children of the vertices in 𝐕i. By the definition of intermediate commitments, each vertex in 𝐕i is the vertical stack of the 𝐀i+1-commitments to its children. Using the vertical decomposition and left multiplication properties of lemma 4.9.1, we have

    𝐙i≡[𝐀i+1⁢𝖥𝗈𝗅𝖽i−1⁢(𝐕i,1;𝐂1,…,𝐂i)⋮𝐀i+1⁢𝖥𝗈𝗅𝖽i−1⁢(𝐕i,mi;𝐂1,…,𝐂i)]modqi+1.

    Applying 𝖡𝖳i and the next challenge gives

    𝖡𝖳i⁢(𝐙i)⁢𝐂i+1≡𝐀i+1⁢𝖥𝗈𝗅𝖽i⁢(𝐕i+1;𝐂1,…,𝐂i+1)=𝐀i+1⁢𝐙i+1modqi+1.

The block transpose only exposes the mi sibling blocks of 𝐙i in the order needed for the next challenge matrix.

We now show an amortized opening protocol for the levelled commitment, which is public-coin, so all consistency and norm checks can be deferred to the end of the verification.

  • Commit.

    The prover computes the levelled commitment 𝐓←F1,d⁢(𝐒) and sends 𝐓.

  • ith Challenge.

    The verifier samples the random challenge matrix 𝐂i with the shape specified above.

  • ith Response.

    After receiving 𝐂i, the prover sends 𝐙i←𝖥𝗈𝗅𝖽i−1⁢(𝐕i;𝐂1,…,𝐂i), of shape n⁢mi×λ elements.

  • Verify.

    After receiving all responses 𝐙1,…,𝐙d, the verifier checks the response are short, and the consistency by

    𝐀1⁢𝐙1 ≡𝐓𝐂1modq1,
    𝐀i+1⁢𝐙i+1 ≡𝖡𝖳i⁢(𝐙i)⁢𝐂i+1modqi+1,

    where i∈[1,d−1].

Knowledge soundness and relaxed extraction.

The opening argument does not extract an exact opening to the original commitment map, and the source of this relaxation is already illustrated in the one-level vanilla construction of [BBC+18a]: special soundness subtracts two accepting responses, so the target is not scaled in the plain SIS setting, but the extracted preimage has a larger norm. If each accepted response has norm bounded by B, then the extracted difference is naturally bounded by 2⁢B.

In the extractor of [BBC+18a], the extracted opening is represented by bounded integers. However, in a levelled commitment, the extracted preimage is not just an opening witness; it is also meant to be an internal value produced by a lower-level commitment. The same internal value is seen in two ways: the upper-layer consumes an integer representative, as SIS is strong when the integer bound is still small, while the lower-layer only sees the corresponding residue class modulo the lower modulus. The gap between these two views is a multiple of the lower modulus, and these multiples are exactly the carry matrices in F~.

For two levels, this definition specializes to a relaxed opening (𝐒‾,𝐑) satisfying

𝐀1⋅((𝐈m1⊗𝐀2)⁢𝐒‾modq2+q2⁢𝐑)≡𝐓modq1.

The extra q2⁢𝐑 term records the missing multiples of q2 when the lower-level computation is viewed as an integer input to the top commitment. This relaxation is still meaningful when parameters force the extracted (𝐒‾,𝐑) to stay within SIS-binding bounds.

Although the commitment is tree shaped, extraction is better viewed depth-wise. All vertices at a same level are folded into one response, and the relaxed opening records the consistency between neighboring layers.

We now define the relaxed version of the levelled commitment map, in parallel with the exact map Fi,j:

F~i,j⁢(𝐒;𝐑i,…,𝐑j−1)={𝐀i⁢𝐒modqi,i=j,F~i,j−1⁢((𝐈Mi,j−1⊗𝐀j)⋅𝐒modqj+qj⁢𝐑j−1;𝐑i,…,𝐑j−2),i<j.

A bounded relaxed opening to 𝐓 is a tuple (𝐒‾,𝐑1,…,𝐑d−1) such that every column of 𝐒‾ has norm at most BS, every column of 𝐑i has ℓ∞ norm at most BR, and

F~1,d⁢(𝐒‾;𝐑1,…,𝐑d−1)≡𝐓modq1.

An exact opening to 𝐓 is the case where all carry matrices 𝐑 are zeroed out.

Similar to the theorem 4.8.7 in [BBC+18a], we define the knowledge soundness for [BLN+20].

Theorem 4.9.2.

If a prover convinces a verifier with probability ε>2−λ+1⋅(4⁢d⁢N)2⁢d, there is an extractor outputs a bounded relaxed opening, where BS=2d⁢B and BRk=2k⁢(Mk−1⁢md+1⁢λk−1+2) for k∈[1,d−1]. It runs in expected 𝗉𝗈𝗅𝗒⁢(λ,1/ε) time.

Noticing

𝐀i+1⁢𝐙i+1≡𝖡𝖳i⁢(𝐙i)⁢𝐂i+1modqi+1

is exactly compressing mi×λ commitments to λ ones as in [BBC+18a], we can use the same row-local rewinding idea as theorem 4.8.7.

Fix the αth column of 𝐓. The desired column-wise relaxed opening has the form

F~1,d⁢(𝐬‾α;𝐫1,…,𝐫d−1)≡𝐭αmodq1,

where 𝐫i is the αth column of 𝐑i for i∈[1,d−1]. Iterating α over [1,md+1] extracts the full set of relaxed opening.

For now, ignore the runtime of sampling challenges for accepting transcripts, and suppose the extractor obtains two accepting transcripts whose first challenges 𝐂1 and 𝐂1′ differ only in the αth row. The verification equation gives

𝐀1⁢𝐙1 ≡𝐓𝐂1modq1,
𝐀1⁢𝐙1′ ≡𝐓𝐂1′modq1.

Choose a coordinate r where the two αth challenge rows differ, and orient the subtraction such that (𝐂1−𝐂1′)α,r=1. Taking the rth column after subtracting the two accepting equations gives

𝐀1⁢(𝐳1,r−𝐳1,r′)≡𝐭αmodq1.

Thus the extractor obtains a bounded preimage of 𝐭α under 𝐀1.

In a levelled commitment, this vector is only the upper-layer input; the tree construction is then used to recursively explain this extracted column by lower-level preimages.

For the next transition, write the row blocks of 𝐙1 as 𝐙1,1,…,𝐙1,m1, so that

𝖡𝖳1⁢(𝐙1)=[𝐙1,1⁢∣⋯∣⁢𝐙1,m1].

The rth column of 𝐙1 is then spread across the columns {rj=r+(j−1)⁢λ}j∈[1,m1] of 𝖡𝖳1⁢(𝐙1), and the verification is

𝐀2⁢𝐙2≡𝖡𝖳1⁢(𝐙1)⁢𝐂2modq2.

To extract the jth block of the rth column of 𝐙1, the extractor therefore rewinds the rjth row of 𝐂2. If two accepting second challenges 𝐂2 and 𝐂2′ differ only in this row, choose a coordinate s and orient such that (𝐂2−𝐂2′)rj,s=1. Taking the sth column after subtracting the two level-two equations gives

𝐀2⁢(𝐳2,s−𝐳2,s′)≡𝖡𝖳1⁢(𝐙1)rjmodq2.

The right hand side is the jth block of the extracted rth column of 𝐙1, which is the rjth column of 𝖡𝖳1⁢(𝐙1). Iterating over j∈[1,m1] explains all blocks of that column; these j’s become the child slots in the transcript tree.

The heavy-row argument lemma 4.8.8 from [Dam10] is still the runtime core of the extractor.

Lemma 4.9.3 (Scaled Heavy Row Lemma).

Let 𝐇∈{0,1}n×m have density at least ε. Fix δ≤ε, and call a row δ-heavy if its row-density is at least δ. If a 1-entry of 𝐇 is sampled uniformly, then its row is δ-heavy with probability at least 1−δ/ε. Moreover, conditioned on a δ-heavy row, resampling a column gives another 1-entry with probability at least δ. If the resampled column is required to differ from the original one, this probability is at least δ−1/m.

Proof.

There are at most δ⁢m⁢n 1-entries in light rows, so at least (ε−δ)⁢m⁢n 1-entries in heavy rows, and the probability lower bound 1−δ/ε holds. The rest follows the same argument in lemma 4.8.8. ∎

The 0-1 matrices are used in the runtime analysis, serving the same challenge-indexing purpose as in [BBC+18a], but now used in the extraction tree. Fix a partial transcript prefix 𝝅i=(𝐂1,𝐙1,…,𝐂i,𝐙i). First define

𝐇i(𝝅i)⁢[χ,𝐂i+1′]⁢[𝐂i+2′,…,𝐂d′]∈{0,1}.

The row is indexed by the prover randomness χ and the current challenge 𝐂i+1′. The column is indexed by the future challenge choice 𝐂i+2′,…,𝐂d′. The entry is 1 iff these choices give a full accepting transcript extending 𝝅i, such that

𝐇i−1𝝅i−1⁢[χ,𝐂i]⁢[𝐂i+1′,…,𝐂d′]=𝐇i(𝝅i)⁢[χ,𝐂i+1′]⁢[𝐂i+2′,…,𝐂d′].

To apply the heavy-row argument to one row of the next challenge, reindex this same 0-1 matrix. Let ρ be a row index in 𝐂i+1′. Write 𝐜i+1,ρ′⁣𝖳 for the ρth row of 𝐂i+1′, and 𝐂^i+1,ρ′ for the rows obtained from 𝐂i+1′ by deleting 𝐜i+1,ρ′⁣𝖳. Define

Hi′⁣(𝝅i,ρ)⁢[χ,𝐂^i+1,ρ′]⁢[𝐜i+1,ρ′⁣𝖳,𝐂i+2′,…,𝐂d′]=Hi(𝝅i)⁢[χ,𝐂i+1′]⁢[𝐂i+2′,…,𝐂d′].

Thus the rows of Hi′⁣(𝝅i,ρ) fix the prover randomness and the non-interesting rows of 𝐂i+1′, while its columns are indexed by the ρth row of 𝐂i+1′ together with all later challenges. At the root, 𝝅0=∅ and the first rewinding uses the αth row of 𝐂1′. Beyond the root, 𝖡𝖳 determines how the current extraction target is seen at the next level: it becomes several target rows in 𝐂i+1′ spaced by λ, as was previously discussed.

The original one-level use sets δ=ε/2, and the probability is at least 1/2 in lemma 4.8.8. For the tree extractor, the same lemma is used with a larger slack K: set the heavy threshold to δ=ε/K, and an accepting entry lands in a heavy row with probability at least 1−1/K. After landing in such a row, resampling only the target row(s) in the challenge being rewound gives another accepting challenge with probability at least ε/K−|𝒞|−λ.

The extractor in [BLN+20] builds a tree of partial transcripts, and the leaves are accepting full transcripts. A state at depth i is written as

𝖳𝖢i⁢([j1,…,ji],𝐂i,𝐙i,t).

Here [j1,…,ji] is the address of the vertex in the tree, where each jk records which child slot was taken:

  • •

    The block of the current column (because of 𝖡𝖳) being followed,

  • •

    One of the two rewounded children, left or right.

The arguments 𝐂i,𝐙i,t are the current challenge, the current response, and the column currently being extracted. Reading the challenges and responses along the addressed path gives the prefix 𝝅i=(𝐂1,𝐙1,…,𝐂i,𝐙i) used when rewinding the prover.

The first step is the same operation with empty prefix and target row α in 𝐂1 (namely the αth column of 𝐓). Sample two first challenges that differ only in this row, run the prover on both, and choose a coordinate t where the two αth rows differ, oriented so the difference is 1. The two resulting children are depth-1 states storing their own 𝐂1,𝐙1, and both carry the index t. Their edge already gives

𝐀1⁢(𝐳1,t(0)−𝐳1,t(1))≡𝐭αmodq1.

Fix a non-root, non-leaf state 𝖳𝖢i⁢([j1,…,ji],𝐂i,𝐙i,t). The first task is to determine which rows of the next challenge have to be rewound. The tth column of 𝐙i is spread by 𝖡𝖳i across the rows

ρℓ=t+(ℓ−1)⁢λ,ℓ∈[1,mi],

of the next challenge 𝐂i+1. For each row ρℓ, the algorithm creates a pair of child candidates by sampling two challenges 𝐂~i+1 and 𝐂~i+1′ that are equivalent except for the ρℓth row, and rewinding the prover from the prefix 𝝅i to obtain the two responses 𝐙~i+1 and 𝐙~i+1′.

For i<d−1, these candidates are the next partial-transcript children. For i=d−1, they must be accepting leaf transcripts instead.

  • •

    For the first child, the extractor keeps resampling the ρℓth row of 𝐂~i+1 and reruns the prover until the resulting transcript is accepting; it aborts after λ⁢K/ε failed attempts.

  • •

    For the second child, it rewinds to the same prefix and repeats the same search for 𝐂~i+1′; it aborts after 2⁢λ⁢K/ε failed attempts.

Choose a coordinate sℓ∈[1,λ] where the two ρℓth challenge rows differ,

(𝐂~i+1−𝐂~i+1′)ρℓ,sℓ≠0,

and orient the pair so the difference is 1. The two responses become the (ℓ,0) and (ℓ,1) children, and both use sℓ as the next column to be extracted. The edge created by this local rewind is

𝐀i+1⁢(𝐳~i+1,sℓ−𝐳~i+1,sℓ′)≡𝖡𝖳i⁢(𝐙i)ρℓmodqi+1.

Thus a depth i state with i≥1 creates 2⁢mi children, and level i>0 has 2i⁢Mi−1 vertices, as in the paper.

Now we can bound the abort probability in the same order as the paper. Let κ denote the per-step heavy-row fraction parameter, and let the retry parameter in the tree construction be K=κ2⁢d. Fix a level-(d−1) vertex V, and write

(V0,V1,…,Vd−2,V)

for the path from the root V0 to V. Let r1,…,rγ be the indices for which Vrj is a right child. Let 𝖺𝖻𝗈𝗋𝗍⁢(V) be the event that the tree construction aborts while trying to complete this fixed leaf vertex V. Write hi⁢(η) for the event that the row selected by this path is η-heavy in 𝐇i, and write hi′⁢(η) for the corresponding event in the reindexed matrix 𝐇i′. The aborting probability for left and right children is derived differently: for a left child it comes directly from 𝐇i, while for a right child it first comes through the reindexed matrix 𝐇i′ and then through 𝐇i.

The first step is the only boundary case. If V1 is a right child, then the first challenge was obtained by resampling one target row while keeping the other rows fixed, so the proof first goes through 𝐇0′:

Pr⁡[𝖺𝖻𝗈𝗋𝗍⁢(V)]≤Pr⁡[𝖺𝖻𝗈𝗋𝗍⁢(V)∣h0′⁢(ε/κ)]+Pr⁡[¬h0′⁢(ε/κ)]≤Pr⁡[𝖺𝖻𝗈𝗋𝗍⁢(V)∣h0′⁢(ε/κ)]+1/κ.

Here 𝐇0′ moves the target row of 𝐂1′ from the row index into the column index: a row of 𝐇0′ is fixed by the non-target rows of 𝐂1′, and is the concatenation of the ordinary 𝐇0 rows obtained by varying that target row. Thus the heavy-row lemma applies to 𝐇0′ after this row-column rearrangement. Conditioned on h0′⁢(ε/κ), the selected row of 𝐇0′ has density at least ε/κ. Now split this selected row according to the value of the target row. Each piece is one ordinary row of 𝐇0, so another application of the heavy-row lemma gives

Pr⁡[¬h0⁢(ε/κ2)∣h0′⁢(ε/κ)]≤1/κ,

thus

Pr⁡[𝖺𝖻𝗈𝗋𝗍⁢(V)∣h0′⁢(ε/κ)]≤Pr⁡[𝖺𝖻𝗈𝗋𝗍⁢(V)∣h0′⁢(ε/κ)∧h0⁢(ε/κ2)]+1/κ.

If V1 is a left child, then the first challenge is sampled as a full challenge, and the bound starts directly from 𝐇0:

Pr⁡[𝖺𝖻𝗈𝗋𝗍⁢(V)]≤Pr⁡[𝖺𝖻𝗈𝗋𝗍⁢(V)∣h0⁢(ε/κ)]+Pr⁡[¬h0⁢(ε/κ)]≤Pr⁡[𝖺𝖻𝗈𝗋𝗍⁢(V)∣h0⁢(ε/κ)]+1/κ.

After this boundary step, the proof continues in the same way through h1,…,hd−2, inserting hrj−1′ immediately before hrj−1 for every right child Vrj on the path. Let E be the conjunction of these heavy-row events, such that the threshold divided by a factor of κ at each peeling step. Then

Pr⁡[¬E]≤(d−1+γ)/κ≤2⁢(d−1)/κ.

On E, the event hd−2⁢(ε/κd−1+γ) holds. Concretely, for the prefix 𝝅d−2 on the path to V, the row 𝐇d−2(𝝅d−2)⁢[χ,𝐂d−1] has density at least ε/κd−1+γ. The columns of this row are indexed by the remaining final challenge 𝐂d, so this is the success probability for one attempt in the first final-challenge search. Since γ≤d−1 and K=κ2⁢d, this local success probability is lower-bounded by ε/κd−1+γ≥ε/K. With λ⁢K/ε attempts, the first leaf abort probability less than e−λ.

The paired leaf search needs one more heavy-row step. Write ρ for the target row of the final challenge determined by this leaf. After the first final challenge is fixed, the extractor resamples only this row for the second final challenge, so the analysis passes to the row

𝐇d−1′⁣(𝝅d−1,ρ)⁢[χ,𝐂^d,ρ′]

whose columns are indexed by the resampled target row. Conditioned on hd−1′⁢(ε/κd+γ), this row has density at least ε/κd+γ. This event fails with probability at most 1/κ, and, when it holds, the successful resampling probability is at least

ε/κd+γ−|𝒞|−λ,

where the subtraction excludes choosing the same target row again. By the lower bound on ε in theorem 4.9.2, this is still at least ε/(2⁢K), and the 2⁢λ⁢K/ε attempts make the second leaf abort probability less than e−λ.

Combining the failure of E, the extra possible failure of hd−1′⁢(ε/κd+γ), and the two leaf searches, for a fixed leaf vertex we get

Pr⁡[𝖺𝖻𝗈𝗋𝗍⁢(V)]≤2⁢e−λ+2⁢d/κ.

The paper sets κ=4⁢d⁢N. Union bounding over all vertices at level d−1, which are 2d−1⁢Md−2 of them, given that d is a constant, and 2d−1⁢Md−2<N, then the aborting probability is at most

2⁢Neλ+2⁢d⁢Nκ=2⁢Neλ+12.

Thus one run of TreeConstruct succeeds with constant probability, up to the negligible 2⁢N/eλ term. For a fixed target column α, running O⁢(λ) independent copies gives a successful tree except with negligible probability. The extractor needs this for all md+1 columns of 𝐓, so it repeats the same procedure for every α∈[1,md+1]. Since md+1≤N, N=𝗉𝗈𝗅𝗒⁢(λ), d is constant, and K=(4⁢d⁢N)2⁢d=𝗉𝗈𝗅𝗒⁢(λ), the total expected running time remains 𝗉𝗈𝗅𝗒⁢(λ,1/ε).

Once the tree is built, extraction is just reading off neighboring children. For a vertex whose current target is the tth column, the two children created for the row ρℓ give

𝐀i+1⁢(𝐳~i+1,sℓ−𝐳~i+1,sℓ′)≡𝖡𝖳i⁢(𝐙i)ρℓmodqi+1.

Collecting these sibling differences over ℓ∈[1,mi] gives the preimage block for the parent target column after the block transition. Repeating down the tree and concatenating the extracted blocks level by level produces the relaxed opening (𝐬‾,𝐫1,…,𝐫d−1) for the chosen column of 𝐓; Iterating over [1,md+1] columns gives the full relaxed opening.

The binding intuition is then about the relaxed relation extracted from the argument. For two levels, write the lifted inputs seen by the top matrix 𝐀1 as

𝐒‾∅ =(𝐈m1⊗𝐀2)⁢𝐒‾modq2+q2⁢𝐑,
𝐒‾∅′ =(𝐈m1⊗𝐀2)⁢𝐒‾′modq2+q2⁢𝐑′.

Both relaxed openings to the same 𝐓 satisfy

𝐀1⁢𝐒‾∅≡𝐀1⁢𝐒‾∅′≡𝐓modq1.

Suppose the two bounded relaxed openings (𝐒‾,𝐑) and (𝐒‾′,𝐑′) are distinct, and both open to the same 𝐓. If 𝐑≠𝐑′, then the two integer representations of the upper-layer inputs are different, and hence

𝐀1⁢(𝐒‾∅−𝐒‾∅′)≡𝟎modq1

gives a short SIS relation for 𝐀1. If 𝐑=𝐑′, then 𝐒‾≠𝐒‾′. In this case, either the lower-layer images of 𝐈m1⊗𝐀2 differ modulo q2, which again makes the lifted top inputs different and gives SIS for 𝐀1, or their equality modulo q2 gives a short nonzero SIS solution for 𝐀2. The separated moduli and norm bounds are chosen so that the differences stay inside the SIS-binding range.

Parameters and slack.

For constant d, the parameter balancing in the paper gives communication

O⁢(N1/(d+1)⋅(d3⁢λ⁢log2⁡N+d⁢λ2)).

If d+1=log⁡N, this becomes

O⁢(λ⁢log5⁡N+λ2⁢log⁡N).

The extractor recovers a relaxed opening: a matrix 𝐒‾ and matrices 𝐑1,…,𝐑d−1 satisfying the relaxed recursive commitment equation. The communication saving therefore comes with knowledge slack, with parameters set so that the slack remains below the relevant SIS bounds.

Bulletproofs-style lattice folding.

The second construction asks whether the Bulletproofs [BBB+18] folding trick can be made lattice-compatible. The starting statement is the RSIS equation

𝐀𝐬=𝐭,𝐀=[𝐀1∣𝐀2]∈R1×k,𝐬=[𝐬1𝐬2]∈Rk,

over R=ℤ⁢[X]/(Xn+1). Here the number of integer secrets is N=k⁢n. In one folding round, the prover sends

𝐥=𝐀1⁢𝐬2,𝐫=𝐀2⁢𝐬1.

The verifier samples a monomial challenge c←r{Xi:i∈ℤ2⁢n}, and the prover responds with

𝐳=𝐬1+c⁢𝐬2.

Then

(c⁢𝐀1+𝐀2)⁢𝐳=c2⁢𝐥+c⁢𝐭+𝐫,

so the verifier can replace the old statement (𝐀,𝐭) by

𝐁=c⁢𝐀1+𝐀2,𝐭′=c2⁢𝐥+c⁢𝐭+𝐫,

with witness 𝐳 of half the length. The verifier also checks that 𝐳 remains short.

Repeating for d rounds reduces the witness length by 2d; setting d=log⁡k leaves a single ring element and gives logarithmic-length communication.

For one round, extraction rewinds to three accepting transcripts with distinct challenges c1,c2,c3 gives

(cj⁢𝐀1+𝐀2)⁢𝐳j=cj2⁢𝐥+cj⁢𝐭+𝐫,j∈[1,3],

for the same 𝐥,𝐫,𝐭. Choose coefficients λ1,λ2,λ3∈R by solving the Vandermonde system

[c12c22c32c1c2c3111]⁢[λ1λ2λ3]=[010].

Then the 𝐥 and 𝐫 terms cancel, and formally

𝐀1⁢∑j=13λj⁢cj⁢𝐳j+𝐀2⁢∑j=13λj⁢𝐳j=𝐀⁢∑j=13λj⁢[cj⁢𝐳j𝐳j]=𝐭.

The challenge set is chosen to consist of monomials Xi. For pairwise distinct monomials, the paper uses the fact that 2/(Xi−Xj) has coefficients in {−1,0,1}, and obtains ‖8⁢λj‖∞≤2⁢n2. After clearing this denominator, one obtains a one-round relaxed preimage

𝐳‾=8⁢∑j=13λj⁢[cj⁢𝐳j𝐳j],𝐀⁢𝐳‾=8⁢𝐭,

with ‖𝐳‾‖∞≤O⁢(12⁢n3⁢p) when each accepted response is bounded by 2⁢p.

This is the sense in which the Bulletproofs-style extraction is approximate: the extractor does not recover a short preimage of the original target 𝐭, but a larger preimage of the scaled target 8⁢𝐭. Recursing through d folds multiplies both effects. Extraction gives a relaxed solution to

𝐀⁢𝐳‾=8d⁢𝐭

with

‖𝐳‾‖∞=O⁢(n3⁢d⁢12d⁢p)

when ‖𝐬‖∞≤p. Thus logarithmic folding buys a much smaller transcript, but pays a large slack: the target is scaled by 8d and the extracted witness norm grows by roughly (12⁢n3)d. With repetition to reduce soundness error, the proof size is

O⁢(λ⁢N⁢log⁡(2d⁢p)2d⁢log⁡n+λ⁢d2⁢n).

Takeaway.

Both constructions are non-PCP routes to succinct, plausibly quantum-safe ZK, but neither extracts an exact original witness. Levelled commitments have larger proofs but smaller, more controllable slack. Bulletproofs folding has the better proof-size expression when slack is cheap, but the relaxed equation 𝐀⁢𝐳‾=8d⁢𝐭 and coefficient growth can force much larger parameters in applications where the extracted witness feeds into other cryptographic components. The paper’s main open direction is to keep the algebraic folding/compression while reducing coefficient growth enough to become competitive with generic PCP/Merkle-tree based post-quantum arguments in concrete size.