Skip to content

Feature: Hash module "packing" #14

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 16 commits into
base: feature/prover-over-koalabear-rebased
Choose a base branch
from
Open

Feature: Hash module "packing" #14

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
16 commits
Select commit Hold shift + click to select a range
0f5f7cc
WIP
Velnbur Jun 11, 2025
bcc3d76
Refactor limb length indexing for consistency and correctness
Velnbur Jun 16, 2025
6a7e626
Fix constraint to apply decompositionHappened in last limb
Velnbur Jun 16, 2025
3b84e61
Fix limb decomposition constraints and carry assignment
Velnbur Jun 16, 2025
ad39e76
Add test cases for limb decomposition with carry
Velnbur Jun 17, 2025
ac42a46
Fix byte packing constraints and test data generation
Velnbur Jun 17, 2025
e8f9b13
Fix limb array length and improve nByte decomposition
Velnbur Jun 18, 2025
1d30a6f
Fix lane bytes extraction in hash lane repacking
Velnbur Jun 18, 2025
0ba36e2
Fix nbrows initialization
Velnbur Jun 18, 2025
3a6e5c5
Fix lane bytes calculation and ceil division
Velnbur Jun 18, 2025
0fe8f39
Fix lane accumulation byte size limit
Velnbur Jun 18, 2025
5d6306a
Remove maxLen field from decomposition struct
Velnbur Jun 18, 2025
0975bb0
Fix lane bytes truncation in hash packing
Velnbur Jun 18, 2025
64b16ec
Add range checks for decomposed limbs and carry values
Velnbur Jun 18, 2025
4748215
Add length consistency check in CLD decomposition
Velnbur Jun 19, 2025
0ff4194
Fix decomposition check by vectorizing expression of
Velnbur Jun 19, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
422 changes: 302 additions & 120 deletions prover/zkevm/prover/hash/packing/cld.go
View file
Open in desktop

Large diffs are not rendered by default.

350 changes: 334 additions & 16 deletions prover/zkevm/prover/hash/packing/cld_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,13 +3,13 @@ package packing
import (
"testing"

"github.com/consensys/linea-monorepo/prover/maths/field"
"github.com/consensys/linea-monorepo/prover/protocol/compiler/dummy"
"github.com/consensys/linea-monorepo/prover/protocol/distributed/pragmas"
"github.com/consensys/linea-monorepo/prover/protocol/wizard"
"github.com/consensys/linea-monorepo/prover/utils"
"github.com/consensys/linea-monorepo/prover/zkevm/prover/common"
"github.com/consensys/linea-monorepo/prover/zkevm/prover/hash/generic"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

// It generates Define and Assign function of Packing module, for testing
Expand All @@ -31,34 +31,24 @@ func makeTestCaseCLDModule(uc generic.HashingUsecase) (
)

imported := Importation{}
ctx := cleaningCtx{}
decomposed := decomposition{}

define = func(build *wizard.Builder) {
comp := build.CompiledIOP
imported = createImportationColumns(comp, size)

createCol := common.CreateColFn(comp, CLEANING, imported.Limb.Size(), pragmas.RightPadded)
ctx = cleaningCtx{
CleanLimb: createCol("CleanLimb"),
Inputs: &cleaningInputs{
imported: imported,
lookup: NewLookupTables(comp)},
}

inp := decompositionInputs{
param: uc,
cleaningCtx: ctx,
param: uc,
Name: "Decomposition",
lookup: NewLookupTables(comp),
imported: imported,
}

decomposed = newDecomposition(comp, inp)
}
prover = func(run *wizard.ProverRuntime) {
// assign the importation columns
assignImportationColumns(run, &imported, numHash, blockSize, size)

// assign all the Packing module.
ctx.assignCleanLimbs(run)
decomposed.Assign(run)
}
return define, prover
Expand All @@ -74,3 +64,331 @@ func TestCLDModule(t *testing.T) {
})
}
}

func TestDecomposeNByte(t *testing.T) {
tests := []struct {
name string
nbytes []field.Element
expected [][]int
}{
{
name: "single byte with value 0",
nbytes: []field.Element{field.NewElement(0)},
expected: [][]int{{0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}},
},
{
name: "single byte with value 1",
nbytes: []field.Element{field.NewElement(1)},
expected: [][]int{{1}, {0}, {0}, {0}, {0}, {0}, {0}, {0}},
},
{
name: "single byte with value 2",
nbytes: []field.Element{field.NewElement(2)},
expected: [][]int{{2}, {0}, {0}, {0}, {0}, {0}, {0}, {0}},
},
{
name: "single byte with value 3 (exceeds MAXNBYTE)",
nbytes: []field.Element{field.NewElement(3)},
expected: [][]int{{2}, {1}, {0}, {0}, {0}, {0}, {0}, {0}},
},
{
name: "single byte with value 5 (multiple limbs)",
nbytes: []field.Element{field.NewElement(5)},
expected: [][]int{{2}, {2}, {1}, {0}, {0}, {0}, {0}, {0}},
},
{
name: "multiple bytes with different values",
nbytes: []field.Element{field.NewElement(2), field.NewElement(4), field.NewElement(7)},
expected: [][]int{
{2, 2, 2},
{0, 2, 2},
{0, 0, 2},
{0, 0, 1},
{0, 0, 0},
{0, 0, 0},
{0, 0, 0},
{0, 0, 0},
},
},
{
name: "value at maximum (16)",
nbytes: []field.Element{field.NewElement(16)},
expected: [][]int{
{2}, {2}, {2}, {2}, {2}, {2}, {2}, {2},
},
},
}

for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
result := decomposeNByte(tc.nbytes)
assert.Equal(t, tc.expected, result, "decomposition result doesn't match expected output")
})
}
}

func alignedFromBytes(a ...byte) field.Element {
zeros := make([]byte, MAXNBYTE-len(a))
bytes := append(a, zeros...)

var value field.Element
value.SetBytes(bytes)
return value
}

func Test_DecomposeLimbsAndCarry(t *testing.T) {
tests := []struct {
name string
limbs [][]field.Element
decomposedLen [][]field.Element
nbytes [][]int
expectedLimbs [][]field.Element
expectedCarry [][]field.Element
}{
{
name: "no decomposition needed",
limbs: [][]field.Element{
{alignedFromBytes(0x12, 0x34)},
{alignedFromBytes(0x56, 0x78)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
},
decomposedLen: [][]field.Element{
{field.NewElement(2)},
{field.NewElement(2)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
},
nbytes: [][]int{
{2},
{2},
{0},
{0},
{0},
{0},
{0},
{0},
},
expectedLimbs: [][]field.Element{
{field.NewElement(0x1234)},
{field.NewElement(0x5678)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
},
expectedCarry: [][]field.Element{
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
},
},
{
name: "decomposition with carry",
limbs: [][]field.Element{
{alignedFromBytes(0x12, 0x34)},
{alignedFromBytes(0x56, 0x78)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
},
decomposedLen: [][]field.Element{
{field.NewElement(1)},
{field.NewElement(2)},
{field.NewElement(1)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
},
nbytes: [][]int{
{2},
{2},
{0},
{0},
{0},
{0},
{0},
{0},
},
expectedLimbs: [][]field.Element{
{field.NewElement(0x12)},
{field.NewElement(0x3456)},
{field.NewElement(0x78)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
},
expectedCarry: [][]field.Element{
{field.NewElement(0x34)},
{field.NewElement(0x78)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
},
},
{
name: "decomposition with carry small",
limbs: [][]field.Element{
{alignedFromBytes(0x12, 0x34)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
{alignedFromBytes(0)},
},
decomposedLen: [][]field.Element{
{field.NewElement(1)},
{field.NewElement(1)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
},
nbytes: [][]int{
{2},
{0},
{0},
{0},
{0},
{0},
{0},
{0},
},
expectedLimbs: [][]field.Element{
{field.NewElement(0x12)},
{field.NewElement(0x34)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
},
expectedCarry: [][]field.Element{
{field.NewElement(0x34)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
{field.NewElement(0)},
},
},
{
name: "decomposition with carry all",
limbs: [][]field.Element{
{alignedFromBytes(0x12, 0x34)},
{alignedFromBytes(0x56, 0x78)},
{alignedFromBytes(0x9a, 0xbc)},
{alignedFromBytes(0xde, 0xf0)},
{alignedFromBytes(0x12, 0x34)},
{alignedFromBytes(0x56, 0x78)},
{alignedFromBytes(0x9a, 0xbc)},
{alignedFromBytes(0xde, 0xf0)},
},
decomposedLen: [][]field.Element{
{field.NewElement(1)},
{field.NewElement(2)},
{field.NewElement(2)},
{field.NewElement(2)},
{field.NewElement(2)},
{field.NewElement(2)},
{field.NewElement(2)},
{field.NewElement(2)},
{field.NewElement(1)},
},
nbytes: [][]int{
{2},
{2},
{2},
{2},
{2},
{2},
{2},
{2},
},
expectedLimbs: [][]field.Element{
{field.NewElement(0x12)},
{field.NewElement(0x3456)},
{field.NewElement(0x789a)},
{field.NewElement(0xbcde)},
{field.NewElement(0xf012)},
{field.NewElement(0x3456)},
{field.NewElement(0x789a)},
{field.NewElement(0xbcde)},
{field.NewElement(0xf0)},
},
expectedCarry: [][]field.Element{
{field.NewElement(0x34)},
{field.NewElement(0x78)},
{field.NewElement(0xbc)},
{field.NewElement(0xf0)},
{field.NewElement(0x34)},
{field.NewElement(0x78)},
{field.NewElement(0xbc)},
{field.NewElement(0xf0)},
},
},
}

for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
resultLimbs, resultCarry := decomposeLimbsAndCarry(tc.limbs, tc.decomposedLen, tc.nbytes)

require.Equal(t, len(tc.expectedLimbs), len(resultLimbs), "number of limb columns should match")
require.Equal(t, len(tc.expectedCarry), len(resultCarry), "number of carry columns should match")

for i := range tc.expectedLimbs {
require.Equal(t, len(tc.expectedLimbs[i]), len(resultLimbs[i]), "limb column %d should have correct length", i)
for j := range tc.expectedLimbs[i] {
require.True(t, tc.expectedLimbs[i][j].Equal(&resultLimbs[i][j]),
"limb[%d][%d] should match: expected %v, got %v", i, j, tc.expectedLimbs[i][j].Bytes(), resultLimbs[i][j].Bytes())
}
}

for i := range tc.expectedCarry {
require.Equal(t, len(tc.expectedCarry[i]), len(resultCarry[i]), "carry column %d should have correct length", i)
for j := range tc.expectedCarry[i] {
require.True(t, tc.expectedCarry[i][j].Equal(&resultCarry[i][j]),
"carry[%d][%d] should match: expected %v, got %v", i, j, tc.expectedCarry[i][j].Bytes(), resultCarry[i][j].Bytes())
}
}
})
}
}
Loading