diff --git a/barretenberg/cpp/pil/vm2/bc_decomposition.pil b/barretenberg/cpp/pil/vm2/bc_decomposition.pil index 1ea22d2afcc7..e38304478316 100644 --- a/barretenberg/cpp/pil/vm2/bc_decomposition.pil +++ b/barretenberg/cpp/pil/vm2/bc_decomposition.pil @@ -1,9 +1,14 @@ +include "precomputed.pil"; + // This file owns the bytecode columns, and other helper columns. // TODO: This does NOT support empty bytecode. -// TODO: Fully constrain. +// TODO: Fully constrain. In particular, the last bytecode of the trace might be truncated +// and not finish with last_of_contract being activated. We expect this to be constrained +// by bytecode hashing. namespace bc_decomposition; pol commit sel; +sel * (1 - sel) = 0; // No relations will be checked if this identity is satisfied. #[skippable_if] sel = 0; @@ -12,22 +17,57 @@ sel = 0; // This includes the "current byte" and the WINDOW_SIZE - 1 lookahead bytes. pol WINDOW_SIZE = 36; +// Internal bytecode identifier which is defined in bc_retrieval.pil pol commit id; // pc counts from 0 to bytecode_length - 1. pol commit pc; // bytes_remaining counts from bytecode_length to 1. pol commit bytes_remaining; -// TODO: Constrain pc is increasing until contract switch. -// TODO: Constrain bytes_remaining is decreasing until contract switch. -// TODO: Constrain bytes_remaining = 1 iff contract switch. -// This column should be 1 iff the contract is switching. +// This column should be 1 iff the contract is switching, i.e., this row is the last one +// of a contract bytecode. This is equivalent to bytes_remaining == 1. pol commit last_of_contract; last_of_contract * (1 - last_of_contract) = 0; // This is the most important column. It contains the bytecode one byte at a time on each row. // If the TX uses several bytecodes, they should go one after the other in this column. pol commit bytes; + +// sel is set to 1 if and only if bytes_remaining != 0 (i.e., sel == 0 iff bytes_remaining == 0) +// This is checked by following relation and utilising inverse of bytes_remaining: bytes_rem_inv +pol commit bytes_rem_inv; + +// Remark: Depending on how bytecode hashing constraints work, we might remove this relation. +#[BC_DEC_SEL_BYTES_REM_NON_ZERO] +bytes_remaining * ((1 - sel) * (1 - bytes_rem_inv) + bytes_rem_inv) - sel = 0; + +// We prove that the trace is contiguous, i.e., as soon as sel == 0 on a given row +// then all subsequent rows have sel == 0. +(1 - precomputed.first_row) * (1 - sel) * sel' = 0; + +// last_of_contract == 1 iff bytes_remaining - 1 == 0 +// We need the helper column for the inverse of bytes_remaining - 1 +pol commit bytes_rem_min_one_inv; + +#[BC_DEC_LAST_CONTRACT_BYTES_REM_ONE] +sel * ((bytes_remaining - 1) * (last_of_contract * (1 - bytes_rem_min_one_inv) + bytes_rem_min_one_inv) + last_of_contract - 1) = 0; + +// Initialization of pc per bytecode to zero +#[BC_DEC_PC_ZERO_INITIALIZATION] +(precomputed.first_row + last_of_contract) * pc' = 0; + +// pc evolution (increment within bytecode) +#[BC_DEC_PC_INCREMENT] +sel * (1 - last_of_contract) * (pc' - pc - 1) = 0; + +// bytes_remaining evolution (decrement within bytecode) +#[BC_DEC_BYTES_REMAINING_DECREMENT] +sel * (1 - last_of_contract) * (bytes_remaining' - bytes_remaining + 1) = 0; + +// TODO: Clarify the need for maintaining the bytecode id constant within a given contract +#[BC_DEC_ID_CONSTANT] +sel * (1 - last_of_contract) * (id' - id) = 0; + // This constrains that the bytes are in the range 0 to 255. #[LOOKUP_BYTECODE_BYTES_ARE_BYTES] sel { bytes } in precomputed.sel_range_8 { precomputed.clk }; @@ -57,7 +97,7 @@ pol commit bytes_pc_plus_1, bytes_pc_plus_2, bytes_pc_plus_3, bytes_pc_plus_4, b // That only the first three bytes are valid. NB: Using this unary trick saves us from doing // WINDOW_SIZE+ lookups and we only do 1 lookup. // -// (3) Then we will expand that uniary representation into a set of WINDOW_SIZE selectors. This is done +// (3) Then we will expand that unary representation into a set of WINDOW_SIZE selectors. This is done // via the usual reconstruction technique. // // (4) Then we apply the selectors to the bytes_pc_plus_n columns. @@ -79,37 +119,87 @@ pol commit bytes_pc_plus_1, bytes_pc_plus_2, bytes_pc_plus_3, bytes_pc_plus_4, b pol commit bytes_to_read; pol commit sel_overflow_correction_needed; sel_overflow_correction_needed * (1 - sel_overflow_correction_needed) = 0; -// We need to constrain bytes_to_read = min(WINDOW_SIZE, bytes_remaining). First we do... -#[BYTECODE_OVERFLOW_CORRECTION_VALUE] +// We need to constrain bytes_to_read = min(WINDOW_SIZE, bytes_remaining) which is equal to +// bytes_remaining if bytes_remaining <= WINDOW_SIZE and WINDOW_SIZE otherwise. + +// Absolute value of WINDOW_SIZE - bytes_remaining +pol commit abs_diff; +// Remark: The factor sel in relation below is only required to use the skippable mechanism. +// sel_overflow_correction_needed = 1 if bytes_remaining < WINDOW_SIZE and +// sel_overflow_correction_needed = 0 if bytes_remaining > WINDOW_SIZE +#[BC_DEC_ABS_DIFF] +sel * (2 * sel_overflow_correction_needed * (WINDOW_SIZE - bytes_remaining) - WINDOW_SIZE + bytes_remaining - abs_diff) = 0; + +// We prove that the abs_diff is positive (and therefore sel_overflow_correction_needed correct) over the integers +// using a range check over 16 bits. We know that WINDOWS_SIZE fits into 16 bits and bytes_remaining cannot be larger +// than the trace size 2^21 (and bytecode hashing/validation could not pass). This provides guarantee that +// abs_diff cannot be the result of an underflow. This would be only possible for bytes_remaining being very close +// to the field order. +#[LOOKUP_BYTECODE_REMAINING_ABS_DIFF_U16] +sel { abs_diff } in precomputed.sel_range_16 { precomputed.clk }; + +#[BC_DEC_OVERFLOW_CORRECTION_VALUE] sel * ((1 - sel_overflow_correction_needed) * (bytes_to_read - WINDOW_SIZE) + sel_overflow_correction_needed * (bytes_to_read - bytes_remaining)) = 0; -// And then we do sel_overflow_correction_needed = 1 iff bytes_remaining < WINDOW_SIZE. -// #[LOOKUP_BYTECODE_REMAINING_U16] -// sel_overflow_correction_needed { bytes_remaining - WINDOW_SIZE } in precomputed.sel_u16 { precomputed.clk } pol commit bytes_to_read_unary; #[LOOKUP_BYTECODE_TO_READ_UNARY] sel { bytes_to_read, bytes_to_read_unary } in precomputed.sel_unary { precomputed.clk, precomputed.as_unary }; // We don't need sel_pc_plus_0 because we always read the current byte. -pol commit sel_pc_plus_0, sel_pc_plus_1, sel_pc_plus_2, sel_pc_plus_3, sel_pc_plus_4, - sel_pc_plus_5, sel_pc_plus_6, sel_pc_plus_7, sel_pc_plus_8, sel_pc_plus_9, - sel_pc_plus_10, sel_pc_plus_11, sel_pc_plus_12, sel_pc_plus_13, sel_pc_plus_14, - sel_pc_plus_15, sel_pc_plus_16, sel_pc_plus_17, sel_pc_plus_18, sel_pc_plus_19, - sel_pc_plus_20, sel_pc_plus_21, sel_pc_plus_22, sel_pc_plus_23, sel_pc_plus_24, - sel_pc_plus_25, sel_pc_plus_26, sel_pc_plus_27, sel_pc_plus_28, sel_pc_plus_29, - sel_pc_plus_30, sel_pc_plus_31, sel_pc_plus_32, sel_pc_plus_33, sel_pc_plus_34, - sel_pc_plus_35; - -#[BYTECODE_UNARY_RECONSTRUCTION] -bytes_to_read_unary = sel * (/*sel_pc_plus_0*/ 2**0 + sel_pc_plus_1 * 2**1 + sel_pc_plus_2 * 2**2 + sel_pc_plus_3 * 2**3 + sel_pc_plus_4 * 2**4 + - sel_pc_plus_5 * 2**5 + sel_pc_plus_6 * 2**6 + sel_pc_plus_7 * 2**7 + sel_pc_plus_8 * 2**8 + sel_pc_plus_9 * 2**9 + - sel_pc_plus_10 * 2**10 + sel_pc_plus_11 * 2**11 + sel_pc_plus_12 * 2**12 + sel_pc_plus_13 * 2**13 + sel_pc_plus_14 * 2**14 + - sel_pc_plus_15 * 2**15 + sel_pc_plus_16 * 2**16 + sel_pc_plus_17 * 2**17 + sel_pc_plus_18 * 2**18 + sel_pc_plus_19 * 2**19 + - sel_pc_plus_20 * 2**20 + sel_pc_plus_21 * 2**21 + sel_pc_plus_22 * 2**22 + sel_pc_plus_23 * 2**23 + sel_pc_plus_24 * 2**24 + - sel_pc_plus_25 * 2**25 + sel_pc_plus_26 * 2**26 + sel_pc_plus_27 * 2**27 + sel_pc_plus_28 * 2**28 + sel_pc_plus_29 * 2**29 + - sel_pc_plus_30 * 2**30 + sel_pc_plus_31 * 2**31 + sel_pc_plus_32 * 2**32 + sel_pc_plus_33 * 2**33 + sel_pc_plus_34 * 2**34 + - sel_pc_plus_35 * 2**35); -// Note: the above relation constrains the selectors to be binary when taken together with the lookup into unary. +pol commit sel_pc_plus_1, sel_pc_plus_2, sel_pc_plus_3, sel_pc_plus_4, sel_pc_plus_5, + sel_pc_plus_6, sel_pc_plus_7, sel_pc_plus_8, sel_pc_plus_9, sel_pc_plus_10, + sel_pc_plus_11, sel_pc_plus_12, sel_pc_plus_13, sel_pc_plus_14, sel_pc_plus_15, + sel_pc_plus_16, sel_pc_plus_17, sel_pc_plus_18, sel_pc_plus_19, sel_pc_plus_20, + sel_pc_plus_21, sel_pc_plus_22, sel_pc_plus_23, sel_pc_plus_24, sel_pc_plus_25, + sel_pc_plus_26, sel_pc_plus_27, sel_pc_plus_28, sel_pc_plus_29, sel_pc_plus_30, + sel_pc_plus_31, sel_pc_plus_32, sel_pc_plus_33, sel_pc_plus_34, sel_pc_plus_35; + +// Remark: We should investigate whether a lookup with 35 precomputed columns might be more efficient. +sel_pc_plus_1 * (1 - sel_pc_plus_1) = 0; +sel_pc_plus_2 * (1 - sel_pc_plus_2) = 0; +sel_pc_plus_3 * (1 - sel_pc_plus_3) = 0; +sel_pc_plus_4 * (1 - sel_pc_plus_4) = 0; +sel_pc_plus_5 * (1 - sel_pc_plus_5) = 0; +sel_pc_plus_6 * (1 - sel_pc_plus_6) = 0; +sel_pc_plus_7 * (1 - sel_pc_plus_7) = 0; +sel_pc_plus_8 * (1 - sel_pc_plus_8) = 0; +sel_pc_plus_9 * (1 - sel_pc_plus_9) = 0; +sel_pc_plus_10 * (1 - sel_pc_plus_10) = 0; +sel_pc_plus_11 * (1 - sel_pc_plus_11) = 0; +sel_pc_plus_12 * (1 - sel_pc_plus_12) = 0; +sel_pc_plus_13 * (1 - sel_pc_plus_13) = 0; +sel_pc_plus_14 * (1 - sel_pc_plus_14) = 0; +sel_pc_plus_15 * (1 - sel_pc_plus_15) = 0; +sel_pc_plus_16 * (1 - sel_pc_plus_16) = 0; +sel_pc_plus_17 * (1 - sel_pc_plus_17) = 0; +sel_pc_plus_18 * (1 - sel_pc_plus_18) = 0; +sel_pc_plus_19 * (1 - sel_pc_plus_19) = 0; +sel_pc_plus_20 * (1 - sel_pc_plus_20) = 0; +sel_pc_plus_21 * (1 - sel_pc_plus_21) = 0; +sel_pc_plus_22 * (1 - sel_pc_plus_22) = 0; +sel_pc_plus_23 * (1 - sel_pc_plus_23) = 0; +sel_pc_plus_24 * (1 - sel_pc_plus_24) = 0; +sel_pc_plus_25 * (1 - sel_pc_plus_25) = 0; +sel_pc_plus_26 * (1 - sel_pc_plus_26) = 0; +sel_pc_plus_27 * (1 - sel_pc_plus_27) = 0; +sel_pc_plus_28 * (1 - sel_pc_plus_28) = 0; +sel_pc_plus_29 * (1 - sel_pc_plus_29) = 0; +sel_pc_plus_30 * (1 - sel_pc_plus_30) = 0; +sel_pc_plus_31 * (1 - sel_pc_plus_31) = 0; +sel_pc_plus_32 * (1 - sel_pc_plus_32) = 0; +sel_pc_plus_33 * (1 - sel_pc_plus_33) = 0; +sel_pc_plus_34 * (1 - sel_pc_plus_34) = 0; +sel_pc_plus_35 * (1 - sel_pc_plus_35) = 0; + +#[BC_DEC_UNARY_RECONSTRUCTION] +sel * (/*sel_pc_plus_0*/ 2**0 + sel_pc_plus_1 * 2**1 + sel_pc_plus_2 * 2**2 + sel_pc_plus_3 * 2**3 + sel_pc_plus_4 * 2**4 + + sel_pc_plus_5 * 2**5 + sel_pc_plus_6 * 2**6 + sel_pc_plus_7 * 2**7 + sel_pc_plus_8 * 2**8 + sel_pc_plus_9 * 2**9 + + sel_pc_plus_10 * 2**10 + sel_pc_plus_11 * 2**11 + sel_pc_plus_12 * 2**12 + sel_pc_plus_13 * 2**13 + sel_pc_plus_14 * 2**14 + + sel_pc_plus_15 * 2**15 + sel_pc_plus_16 * 2**16 + sel_pc_plus_17 * 2**17 + sel_pc_plus_18 * 2**18 + sel_pc_plus_19 * 2**19 + + sel_pc_plus_20 * 2**20 + sel_pc_plus_21 * 2**21 + sel_pc_plus_22 * 2**22 + sel_pc_plus_23 * 2**23 + sel_pc_plus_24 * 2**24 + + sel_pc_plus_25 * 2**25 + sel_pc_plus_26 * 2**26 + sel_pc_plus_27 * 2**27 + sel_pc_plus_28 * 2**28 + sel_pc_plus_29 * 2**29 + + sel_pc_plus_30 * 2**30 + sel_pc_plus_31 * 2**31 + sel_pc_plus_32 * 2**32 + sel_pc_plus_33 * 2**33 + sel_pc_plus_34 * 2**34 + + sel_pc_plus_35 * 2**35 - bytes_to_read_unary) = 0; // Constrain shifted columns. bytes_pc_plus_1 = sel_pc_plus_1 * bytes'; diff --git a/barretenberg/cpp/pil/vm2/bc_retrieval.pil b/barretenberg/cpp/pil/vm2/bc_retrieval.pil index 2da9f3a28b8b..9b9a3d520fc5 100644 --- a/barretenberg/cpp/pil/vm2/bc_retrieval.pil +++ b/barretenberg/cpp/pil/vm2/bc_retrieval.pil @@ -6,6 +6,8 @@ pol commit sel; #[skippable_if] sel = 0; +// This id is generated at runtime starting from zero and incremented by 1. +// The primary source of bytecode_id is this sub-trace. pol commit bytecode_id; pol commit err; // some error occurred. pol commit address; // contract address. diff --git a/barretenberg/cpp/pil/vm2/instr_fetching.pil b/barretenberg/cpp/pil/vm2/instr_fetching.pil index 5bbdf6f90e08..c11b404bf630 100644 --- a/barretenberg/cpp/pil/vm2/instr_fetching.pil +++ b/barretenberg/cpp/pil/vm2/instr_fetching.pil @@ -37,7 +37,7 @@ pol commit fmt_3_op_u8; // pc, // bytecode_id, // bd0, bd1, bd2, bd3, bd4, -// bd5, bd7, bd8, bd9, bd10, +// bd5, bd6, bd7, bd8, bd9, bd10, // bd11, bd12, bd13, bd14, bd15, // bd16, bd17, bd18, bd19, bd20, // bd21, bd22, bd23, bd24, bd25, @@ -47,7 +47,7 @@ pol commit fmt_3_op_u8; // bc_decomposition.pc, // bc_decomposition.id, // bc_decomposition.bytes_pc_plus_0, bc_decomposition.bytes_pc_plus_1, bc_decomposition.bytes_pc_plus_2, bc_decomposition.bytes_pc_plus_3, bc_decomposition.bytes_pc_plus_4, -// bc_decomposition.bytes_pc_plus_5, bc_decomposition.bytes_pc_plus_7, bc_decomposition.bytes_pc_plus_8, bc_decomposition.bytes_pc_plus_9, bc_decomposition.bytes_pc_plus_10, +// bc_decomposition.bytes_pc_plus_5, bc_decomposition.bytes_pc_plus_6, bc_decomposition.bytes_pc_plus_7, bc_decomposition.bytes_pc_plus_8, bc_decomposition.bytes_pc_plus_9, bc_decomposition.bytes_pc_plus_10, // bc_decomposition.bytes_pc_plus_11, bc_decomposition.bytes_pc_plus_12, bc_decomposition.bytes_pc_plus_13, bc_decomposition.bytes_pc_plus_14, bc_decomposition.bytes_pc_plus_15, // bc_decomposition.bytes_pc_plus_16, bc_decomposition.bytes_pc_plus_17, bc_decomposition.bytes_pc_plus_18, bc_decomposition.bytes_pc_plus_19, bc_decomposition.bytes_pc_plus_20, // bc_decomposition.bytes_pc_plus_21, bc_decomposition.bytes_pc_plus_22, bc_decomposition.bytes_pc_plus_23, bc_decomposition.bytes_pc_plus_24, bc_decomposition.bytes_pc_plus_25, diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bc_decomposition.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bc_decomposition.test.cpp index 7e25b064d329..fe9d600ab008 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bc_decomposition.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bc_decomposition.test.cpp @@ -6,10 +6,12 @@ #include #include "barretenberg/vm2/constraining/testing/check_relation.hpp" +#include "barretenberg/vm2/generated/columns.hpp" #include "barretenberg/vm2/generated/flavor_settings.hpp" #include "barretenberg/vm2/generated/relations/bc_decomposition.hpp" #include "barretenberg/vm2/testing/macros.hpp" #include "barretenberg/vm2/tracegen/bytecode_trace.hpp" +#include "barretenberg/vm2/tracegen/precomputed_trace.hpp" #include "barretenberg/vm2/tracegen/test_trace_container.hpp" namespace bb::avm2::constraining { @@ -31,6 +33,12 @@ std::vector random_bytes(size_t n) return bytes; } +void init_trace(TestTraceContainer& trace) +{ + // Add first row. + trace.set(C::precomputed_first_row, 0, 1); +} + TEST(BytecodeDecompositionConstrainingTest, EmptyRow) { TestTraceContainer trace({ @@ -43,6 +51,7 @@ TEST(BytecodeDecompositionConstrainingTest, EmptyRow) TEST(BytecodeDecompositionConstrainingTest, SingleBytecode) { TestTraceContainer trace; + init_trace(trace); BytecodeTraceBuilder builder; builder.process_decomposition( { { .bytecode_id = 1, .bytecode = std::make_shared>(random_bytes(40)) } }, trace); @@ -55,6 +64,7 @@ TEST(BytecodeDecompositionConstrainingTest, ShortSingleBytecode) { // Bytecode is shorter than the sliding window. TestTraceContainer trace; + init_trace(trace); BytecodeTraceBuilder builder; builder.process_decomposition( { { .bytecode_id = 1, .bytecode = std::make_shared>(random_bytes(5)) } }, trace); @@ -66,6 +76,7 @@ TEST(BytecodeDecompositionConstrainingTest, ShortSingleBytecode) TEST(BytecodeDecompositionConstrainingTest, MultipleBytecodes) { TestTraceContainer trace; + init_trace(trace); BytecodeTraceBuilder builder; builder.process_decomposition( { { .bytecode_id = 1, .bytecode = std::make_shared>(random_bytes(40)) }, @@ -79,6 +90,7 @@ TEST(BytecodeDecompositionConstrainingTest, MultipleBytecodes) TEST(BytecodeDecompositionConstrainingTest, MultipleBytecodesWithShortOnes) { TestTraceContainer trace; + init_trace(trace); BytecodeTraceBuilder builder; builder.process_decomposition( { { .bytecode_id = 1, .bytecode = std::make_shared>(random_bytes(40)) }, @@ -92,5 +104,203 @@ TEST(BytecodeDecompositionConstrainingTest, MultipleBytecodesWithShortOnes) check_relation(trace); } +TEST(BytecodeDecompositionConstrainingTest, NegativeDeactivatedSel) +{ + TestTraceContainer trace = TestTraceContainer::from_rows({ + { + .bc_decomposition_bytes_rem_inv = FF(33).invert(), + .bc_decomposition_bytes_remaining = 33, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_bytes_rem_inv = FF(32).invert(), + .bc_decomposition_bytes_remaining = 32, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_bytes_rem_inv = FF(31).invert(), + .bc_decomposition_bytes_remaining = 31, + .bc_decomposition_sel = 1, + }, + }); + + check_relation(trace, bc_decomposition::SR_BC_DEC_SEL_BYTES_REM_NON_ZERO); + trace.set(C::bc_decomposition_sel, 2, 0); // Mutate to wrong value + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, bc_decomposition::SR_BC_DEC_SEL_BYTES_REM_NON_ZERO), + "BC_DEC_SEL_BYTES_REM_NON_ZERO"); +} + +TEST(BytecodeDecompositionConstrainingTest, NegativeDeactivateLastContract) +{ + TestTraceContainer trace = TestTraceContainer::from_rows({ + { + .bc_decomposition_bytes_rem_min_one_inv = FF(2).invert(), + .bc_decomposition_bytes_remaining = 3, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_bytes_rem_min_one_inv = 1, + .bc_decomposition_bytes_remaining = 2, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_bytes_rem_min_one_inv = 0, + .bc_decomposition_bytes_remaining = 1, + .bc_decomposition_last_of_contract = 1, + .bc_decomposition_sel = 1, + }, + }); + + check_relation(trace, bc_decomposition::SR_BC_DEC_LAST_CONTRACT_BYTES_REM_ONE); + trace.set(C::bc_decomposition_last_of_contract, 2, 0); // Mutate to wrong value + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, bc_decomposition::SR_BC_DEC_LAST_CONTRACT_BYTES_REM_ONE), + "BC_DEC_LAST_CONTRACT_BYTES_REM_ONE"); +} + +TEST(BytecodeDecompositionConstrainingTest, NegativePcWrongInitializationFirstRow) +{ + TestTraceContainer trace = TestTraceContainer::from_rows({ + { .precomputed_first_row = 1 }, + { + .bc_decomposition_pc = 0, + .bc_decomposition_sel = 1, + }, + }); + + check_relation(trace, bc_decomposition::SR_BC_DEC_PC_ZERO_INITIALIZATION); + trace.set(C::bc_decomposition_pc, 1, 7); // Mutate to wrong value + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, bc_decomposition::SR_BC_DEC_PC_ZERO_INITIALIZATION), + "BC_DEC_PC_ZERO_INITIALIZATION"); +} + +TEST(BytecodeDecompositionConstrainingTest, NegativePcWrongInitializationInside) +{ + TestTraceContainer trace = TestTraceContainer::from_rows({ + { .bc_decomposition_last_of_contract = 1 }, + { + .bc_decomposition_pc = 0, + .bc_decomposition_sel = 1, + }, + }); + + check_relation(trace, bc_decomposition::SR_BC_DEC_PC_ZERO_INITIALIZATION); + trace.set(C::bc_decomposition_pc, 1, 32); // Mutate to wrong value + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, bc_decomposition::SR_BC_DEC_PC_ZERO_INITIALIZATION), + "BC_DEC_PC_ZERO_INITIALIZATION"); +} + +TEST(BytecodeDecompositionConstrainingTest, NegativePcWrongIncrement) +{ + TestTraceContainer trace = TestTraceContainer::from_rows({ + { + .bc_decomposition_pc = 5, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_pc = 6, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_last_of_contract = 1, // Required otherwise the test passes trivially + .bc_decomposition_pc = 7, + .bc_decomposition_sel = 1, + }, + }); + + check_relation(trace, bc_decomposition::SR_BC_DEC_PC_INCREMENT); + trace.set(C::bc_decomposition_pc, 2, 6); // Mutate to wrong value + EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bc_decomposition::SR_BC_DEC_PC_INCREMENT), + "BC_DEC_PC_INCREMENT"); +} + +TEST(BytecodeDecompositionConstrainingTest, NegativeBytesRemWrongDecrement) +{ + TestTraceContainer trace = TestTraceContainer::from_rows({ + { + .bc_decomposition_bytes_remaining = 5, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_bytes_remaining = 4, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_bytes_remaining = 3, + .bc_decomposition_last_of_contract = 1, // Required otherwise the test passes trivially + .bc_decomposition_sel = 1, + }, + }); + + check_relation(trace, bc_decomposition::SR_BC_DEC_BYTES_REMAINING_DECREMENT); + trace.set(C::bc_decomposition_bytes_remaining, 0, 4); // Mutate to wrong value + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, bc_decomposition::SR_BC_DEC_BYTES_REMAINING_DECREMENT), + "BC_DEC_BYTES_REMAINING_DECREMENT"); +} + +TEST(BytecodeDecompositionConstrainingTest, NegativeMutateBytecodeId) +{ + TestTraceContainer trace = TestTraceContainer::from_rows({ + { + .bc_decomposition_id = 147, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_id = 147, + .bc_decomposition_sel = 1, + }, + { + .bc_decomposition_id = 147, + .bc_decomposition_last_of_contract = 1, // Required otherwise the test passes trivially + .bc_decomposition_sel = 1, + }, + }); + + check_relation(trace, bc_decomposition::SR_BC_DEC_ID_CONSTANT); + trace.set(C::bc_decomposition_id, 2, 77); // Mutate to wrong value + EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bc_decomposition::SR_BC_DEC_ID_CONSTANT), + "BC_DEC_ID_CONSTANT"); +} + +TEST(BytecodeDecompositionConstrainingTest, NegativeWrongBytesToReadNoCorrection) +{ + TestTraceContainer trace = TestTraceContainer::from_rows({ + { + .bc_decomposition_bytes_remaining = 75, + .bc_decomposition_bytes_to_read = tracegen::DECOMPOSE_WINDOW_SIZE, + .bc_decomposition_sel = 1, + }, + }); + + check_relation(trace, bc_decomposition::SR_BC_DEC_OVERFLOW_CORRECTION_VALUE); + trace.set(C::bc_decomposition_bytes_to_read, 0, 75); // Mutate to wrong value (bytes_remaining) + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, bc_decomposition::SR_BC_DEC_OVERFLOW_CORRECTION_VALUE), + "BC_DEC_OVERFLOW_CORRECTION_VALUE"); +} + +TEST(BytecodeDecompositionConstrainingTest, NegativeWrongBytesToReadWithCorrection) +{ + TestTraceContainer trace = TestTraceContainer::from_rows({ + { + .bc_decomposition_bytes_remaining = 13, + .bc_decomposition_bytes_to_read = 13, + .bc_decomposition_sel = 1, + .bc_decomposition_sel_overflow_correction_needed = 1, + }, + }); + + check_relation(trace, bc_decomposition::SR_BC_DEC_OVERFLOW_CORRECTION_VALUE); + trace.set( + C::bc_decomposition_bytes_to_read, 0, tracegen::DECOMPOSE_WINDOW_SIZE); // Mutate to wrong value (WINDOWS_SIZE) + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, bc_decomposition::SR_BC_DEC_OVERFLOW_CORRECTION_VALUE), + "BC_DEC_OVERFLOW_CORRECTION_VALUE"); +} + } // namespace } // namespace bb::avm2::constraining diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bitwise.test.cpp index 61b5b878eeca..decc31579752 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bitwise.test.cpp @@ -146,13 +146,19 @@ TEST(BitwiseConstrainingTest, NegativeWrongInit) .bitwise_acc_ia = 25, .bitwise_acc_ib = 25, .bitwise_acc_ic = 25, - .bitwise_ia_byte = 24, - .bitwise_ib_byte = 27, - .bitwise_ic_byte = 28, + .bitwise_ia_byte = 25, + .bitwise_ib_byte = 25, + .bitwise_ic_byte = 25, .bitwise_last = 1, }, }); + check_relation(trace, bitwise::SR_BITW_INIT_A, bitwise::SR_BITW_INIT_B, bitwise::SR_BITW_INIT_C); + + trace.set(C::bitwise_ia_byte, 0, 24); // Mutate to wrong value violating BITW_INIT_A + trace.set(C::bitwise_ib_byte, 0, 27); // Mutate to wrong value violating BITW_INIT_B + trace.set(C::bitwise_ic_byte, 0, 28); // Mutate to wrong value violating BITW_INIT_C + EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_INIT_A), "BITW_INIT_A"); EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_INIT_B), "BITW_INIT_B"); EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_INIT_C), "BITW_INIT_C"); @@ -173,8 +179,20 @@ TEST(BitwiseConstrainingTest, NegativeTruncateCtr) .bitwise_ctr = 2, .bitwise_sel = 1, }, + { + .bitwise_ctr = 1, + .bitwise_last = 1, + .bitwise_sel = 1, + }, }); + check_relation(trace, bitwise::SR_BITW_CTR_DECREMENT); + + trace.set(C::bitwise_ctr, 3, 0); + trace.set(C::bitwise_last, 3, 0); + trace.set(C::bitwise_sel, 3, 0); + + // Trace nows ends with bitwise_ctr == 2 without bitwise_last being set. EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_CTR_DECREMENT), "BITW_CTR_DECREMENT"); } @@ -186,12 +204,14 @@ TEST(BitwiseConstrainingTest, NegativeGapCtr) .bitwise_sel = 1, }, { - .bitwise_ctr = 2, + .bitwise_ctr = 3, .bitwise_last = 1, .bitwise_sel = 1, }, }); + check_relation(trace, bitwise::SR_BITW_CTR_DECREMENT); + trace.set(C::bitwise_ctr, 1, 2); // Mutate to wrong value (ctr decreases from 4 to 2) EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_CTR_DECREMENT), "BITW_CTR_DECREMENT"); } @@ -200,20 +220,24 @@ TEST(BitwiseConstrainingTest, NegativeLastSetBeforeEnd) TestTraceContainer trace = TestTraceContainer::from_rows({ { .bitwise_ctr = 8, + .bitwise_ctr_min_one_inv = FF(7).invert(), .bitwise_sel = 1, }, { .bitwise_ctr = 7, + .bitwise_ctr_min_one_inv = FF(6).invert(), .bitwise_sel = 1, }, { .bitwise_ctr = 6, - .bitwise_last = 1, + .bitwise_ctr_min_one_inv = FF(5).invert(), .bitwise_sel = 1, }, }); + check_relation(trace, bitwise::SR_BITW_LAST_FOR_CTR_ONE); + trace.set(C::bitwise_last, 2, 1); // Mutate to wrong value (wrongly activate bitwise_last on last row) EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_LAST_FOR_CTR_ONE), "BITW_LAST_FOR_CTR_ONE"); } @@ -223,18 +247,23 @@ TEST(BitwiseConstrainingTest, NegativeDeactivateRow) TestTraceContainer trace = TestTraceContainer::from_rows({ { .bitwise_ctr = 8, + .bitwise_ctr_inv = FF(8).invert(), .bitwise_sel = 1, }, { .bitwise_ctr = 7, - .bitwise_sel = 0, + .bitwise_ctr_inv = FF(7).invert(), + .bitwise_sel = 1, }, { .bitwise_ctr = 6, + .bitwise_ctr_inv = FF(6).invert(), .bitwise_sel = 1, }, }); + check_relation(trace, bitwise::SR_BITW_SEL_CTR_NON_ZERO); + trace.set(C::bitwise_sel, 1, 0); // Mutate to wrong value EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_SEL_CTR_NON_ZERO), "BITW_SEL_CTR_NON_ZERO"); } @@ -246,7 +275,7 @@ TEST(BitwiseConstrainingTest, NegativeChangeOpIDBeforeEnd) .bitwise_op_id = static_cast(BitwiseOperation::XOR), }, { - .bitwise_op_id = static_cast(BitwiseOperation::AND), + .bitwise_op_id = static_cast(BitwiseOperation::XOR), }, { .bitwise_last = 1, @@ -254,6 +283,8 @@ TEST(BitwiseConstrainingTest, NegativeChangeOpIDBeforeEnd) }, }); + check_relation(trace, bitwise::SR_BITW_OP_ID_REL); + trace.set(C::bitwise_op_id, 1, static_cast(BitwiseOperation::AND)); // Mutate to wrong value EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_OP_ID_REL), "BITW_OP_ID_REL"); } @@ -261,9 +292,9 @@ TEST(BitwiseConstrainingTest, NegativeWrongAccumulation) { TestTraceContainer trace = TestTraceContainer::from_rows({ { - .bitwise_acc_ia = 0xaa1f, // Correct: 0xaa11 - .bitwise_acc_ib = 0xbb2f, // Correct: 0xbb22 - .bitwise_acc_ic = 0xcc3f, // Correct: 0xcc33 + .bitwise_acc_ia = 0xaa11, + .bitwise_acc_ib = 0xbb22, + .bitwise_acc_ic = 0xcc33, .bitwise_ia_byte = 0x11, .bitwise_ib_byte = 0x22, .bitwise_ic_byte = 0x33, @@ -276,6 +307,12 @@ TEST(BitwiseConstrainingTest, NegativeWrongAccumulation) }, }); + check_relation(trace, bitwise::SR_BITW_ACC_REL_A, bitwise::SR_BITW_ACC_REL_B, bitwise::SR_BITW_ACC_REL_C); + + trace.set(C::bitwise_acc_ia, 0, 0xaa1f); // Mutate to wrong value violating BITW_ACC_REL_A + trace.set(C::bitwise_acc_ib, 0, 0xbb2f); // Mutate to wrong value violating BITW_ACC_REL_B + trace.set(C::bitwise_acc_ic, 0, 0xcc3f); // Mutate to wrong value violating BITW_ACC_REL_C + EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_ACC_REL_A), "BITW_ACC_REL_A"); EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_ACC_REL_B), "BITW_ACC_REL_B"); EXPECT_THROW_WITH_MESSAGE(check_relation(trace, bitwise::SR_BITW_ACC_REL_C), "BITW_ACC_REL_C"); diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp index 8cce3fbd9968..e222f8f3db63 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp @@ -10,16 +10,16 @@ namespace bb::avm2 { // The entities that will be used in the flavor. // clang-format off #define AVM2_PRECOMPUTED_ENTITIES precomputed_as_unary, precomputed_bitwise_input_a, precomputed_bitwise_input_b, precomputed_bitwise_op_id, precomputed_bitwise_output, precomputed_clk, precomputed_first_row, precomputed_integral_tag_length, precomputed_power_of_2, precomputed_sel_bitwise, precomputed_sel_integral_tag, precomputed_sel_range_16, precomputed_sel_range_8, precomputed_sel_sha256_compression, precomputed_sel_unary, precomputed_sha256_compression_round_constant -#define AVM2_WIRE_ENTITIES execution_input, alu_dst_addr, alu_ia, alu_ia_addr, alu_ib, alu_ib_addr, alu_ic, alu_op, alu_sel_op_add, bc_decomposition_bytes, bc_decomposition_bytes_pc_plus_1, bc_decomposition_bytes_pc_plus_10, bc_decomposition_bytes_pc_plus_11, bc_decomposition_bytes_pc_plus_12, bc_decomposition_bytes_pc_plus_13, bc_decomposition_bytes_pc_plus_14, bc_decomposition_bytes_pc_plus_15, bc_decomposition_bytes_pc_plus_16, bc_decomposition_bytes_pc_plus_17, bc_decomposition_bytes_pc_plus_18, bc_decomposition_bytes_pc_plus_19, bc_decomposition_bytes_pc_plus_2, bc_decomposition_bytes_pc_plus_20, bc_decomposition_bytes_pc_plus_21, bc_decomposition_bytes_pc_plus_22, bc_decomposition_bytes_pc_plus_23, bc_decomposition_bytes_pc_plus_24, bc_decomposition_bytes_pc_plus_25, bc_decomposition_bytes_pc_plus_26, bc_decomposition_bytes_pc_plus_27, bc_decomposition_bytes_pc_plus_28, bc_decomposition_bytes_pc_plus_29, bc_decomposition_bytes_pc_plus_3, bc_decomposition_bytes_pc_plus_30, bc_decomposition_bytes_pc_plus_31, bc_decomposition_bytes_pc_plus_32, bc_decomposition_bytes_pc_plus_33, bc_decomposition_bytes_pc_plus_34, bc_decomposition_bytes_pc_plus_35, bc_decomposition_bytes_pc_plus_4, bc_decomposition_bytes_pc_plus_5, bc_decomposition_bytes_pc_plus_6, bc_decomposition_bytes_pc_plus_7, bc_decomposition_bytes_pc_plus_8, bc_decomposition_bytes_pc_plus_9, bc_decomposition_bytes_remaining, bc_decomposition_bytes_to_read, bc_decomposition_bytes_to_read_unary, bc_decomposition_id, bc_decomposition_last_of_contract, bc_decomposition_pc, bc_decomposition_sel, bc_decomposition_sel_overflow_correction_needed, bc_decomposition_sel_pc_plus_0, bc_decomposition_sel_pc_plus_1, bc_decomposition_sel_pc_plus_10, bc_decomposition_sel_pc_plus_11, bc_decomposition_sel_pc_plus_12, bc_decomposition_sel_pc_plus_13, bc_decomposition_sel_pc_plus_14, bc_decomposition_sel_pc_plus_15, bc_decomposition_sel_pc_plus_16, bc_decomposition_sel_pc_plus_17, bc_decomposition_sel_pc_plus_18, bc_decomposition_sel_pc_plus_19, bc_decomposition_sel_pc_plus_2, bc_decomposition_sel_pc_plus_20, bc_decomposition_sel_pc_plus_21, bc_decomposition_sel_pc_plus_22, bc_decomposition_sel_pc_plus_23, bc_decomposition_sel_pc_plus_24, bc_decomposition_sel_pc_plus_25, bc_decomposition_sel_pc_plus_26, bc_decomposition_sel_pc_plus_27, bc_decomposition_sel_pc_plus_28, bc_decomposition_sel_pc_plus_29, bc_decomposition_sel_pc_plus_3, bc_decomposition_sel_pc_plus_30, bc_decomposition_sel_pc_plus_31, bc_decomposition_sel_pc_plus_32, bc_decomposition_sel_pc_plus_33, bc_decomposition_sel_pc_plus_34, bc_decomposition_sel_pc_plus_35, bc_decomposition_sel_pc_plus_4, bc_decomposition_sel_pc_plus_5, bc_decomposition_sel_pc_plus_6, bc_decomposition_sel_pc_plus_7, bc_decomposition_sel_pc_plus_8, bc_decomposition_sel_pc_plus_9, bc_retrieval_address, bc_retrieval_artifact_hash, bc_retrieval_bytecode_id, bc_retrieval_class_id, bc_retrieval_deployer_addr, bc_retrieval_err, bc_retrieval_incoming_viewing_key_x, bc_retrieval_incoming_viewing_key_y, bc_retrieval_init_hash, bc_retrieval_nullifier_key_x, bc_retrieval_nullifier_key_y, bc_retrieval_outgoing_viewing_key_x, bc_retrieval_outgoing_viewing_key_y, bc_retrieval_private_function_root, bc_retrieval_public_bytecode_commitment, bc_retrieval_salt, bc_retrieval_sel, bc_retrieval_tagging_key_x, bc_retrieval_tagging_key_y, bitwise_acc_ia, bitwise_acc_ib, bitwise_acc_ic, bitwise_ctr, bitwise_ctr_inv, bitwise_ctr_min_one_inv, bitwise_ia_byte, bitwise_ib_byte, bitwise_ic_byte, bitwise_last, bitwise_op_id, bitwise_sel, bitwise_start, bitwise_tag, ecc_add_op, ecc_double_op, ecc_inv_2_p_y, ecc_inv_x_diff, ecc_inv_y_diff, ecc_lambda, ecc_p_is_inf, ecc_p_x, ecc_p_y, ecc_q_is_inf, ecc_q_x, ecc_q_y, ecc_r_is_inf, ecc_r_x, ecc_r_y, ecc_result_infinity, ecc_sel, ecc_x_match, ecc_y_match, execution_addressing_error_idx, execution_addressing_error_kind, execution_base_address_tag, execution_base_address_val, execution_bytecode_id, execution_clk, execution_ex_opcode, execution_indirect, execution_last, execution_op1, execution_op1_after_relative, execution_op2, execution_op2_after_relative, execution_op3, execution_op3_after_relative, execution_op4, execution_op4_after_relative, execution_pc, execution_rop1, execution_rop2, execution_rop3, execution_rop4, execution_sel, execution_sel_addressing_error, execution_sel_op1_is_address, execution_sel_op2_is_address, execution_sel_op3_is_address, execution_sel_op4_is_address, instr_fetching_bd0, instr_fetching_bd1, instr_fetching_bd10, instr_fetching_bd11, instr_fetching_bd12, instr_fetching_bd13, instr_fetching_bd14, instr_fetching_bd15, instr_fetching_bd16, instr_fetching_bd17, instr_fetching_bd18, instr_fetching_bd19, instr_fetching_bd2, instr_fetching_bd20, instr_fetching_bd21, instr_fetching_bd22, instr_fetching_bd23, instr_fetching_bd24, instr_fetching_bd25, instr_fetching_bd26, instr_fetching_bd27, instr_fetching_bd28, instr_fetching_bd29, instr_fetching_bd3, instr_fetching_bd30, instr_fetching_bd31, instr_fetching_bd32, instr_fetching_bd33, instr_fetching_bd34, instr_fetching_bd35, instr_fetching_bd4, instr_fetching_bd5, instr_fetching_bd6, instr_fetching_bd7, instr_fetching_bd8, instr_fetching_bd9, instr_fetching_bytecode_id, instr_fetching_ex_opcode, instr_fetching_fmt_3_op_u8, instr_fetching_indirect, instr_fetching_op1, instr_fetching_op2, instr_fetching_op3, instr_fetching_op4, instr_fetching_pc, instr_fetching_sel, range_check_dyn_diff, range_check_dyn_rng_chk_bits, range_check_dyn_rng_chk_pow_2, range_check_is_lte_u112, range_check_is_lte_u128, range_check_is_lte_u16, range_check_is_lte_u32, range_check_is_lte_u48, range_check_is_lte_u64, range_check_is_lte_u80, range_check_is_lte_u96, range_check_rng_chk_bits, range_check_sel, range_check_sel_r0_16_bit_rng_lookup, range_check_sel_r1_16_bit_rng_lookup, range_check_sel_r2_16_bit_rng_lookup, range_check_sel_r3_16_bit_rng_lookup, range_check_sel_r4_16_bit_rng_lookup, range_check_sel_r5_16_bit_rng_lookup, range_check_sel_r6_16_bit_rng_lookup, range_check_u16_r0, range_check_u16_r1, range_check_u16_r2, range_check_u16_r3, range_check_u16_r4, range_check_u16_r5, range_check_u16_r6, range_check_u16_r7, range_check_value, sha256_a, sha256_a_and_b, sha256_a_and_b_xor_a_and_c, sha256_a_and_c, sha256_a_rotr_13, sha256_a_rotr_2, sha256_a_rotr_22, sha256_a_rotr_2_xor_a_rotr_13, sha256_and_sel, sha256_b, sha256_b_and_c, sha256_c, sha256_ch, sha256_clk, sha256_computed_w_lhs, sha256_computed_w_rhs, sha256_d, sha256_dummy_zero, sha256_e, sha256_e_and_f, sha256_e_rotr_11, sha256_e_rotr_25, sha256_e_rotr_6, sha256_e_rotr_6_xor_e_rotr_11, sha256_f, sha256_g, sha256_h, sha256_helper_w0, sha256_helper_w1, sha256_helper_w10, sha256_helper_w11, sha256_helper_w12, sha256_helper_w13, sha256_helper_w14, sha256_helper_w15, sha256_helper_w2, sha256_helper_w3, sha256_helper_w4, sha256_helper_w5, sha256_helper_w6, sha256_helper_w7, sha256_helper_w8, sha256_helper_w9, sha256_init_a, sha256_init_b, sha256_init_c, sha256_init_d, sha256_init_e, sha256_init_f, sha256_init_g, sha256_init_h, sha256_input_offset, sha256_is_input_round, sha256_latch, sha256_lhs_a_13, sha256_lhs_a_2, sha256_lhs_a_22, sha256_lhs_e_11, sha256_lhs_e_25, sha256_lhs_e_6, sha256_lhs_w_10, sha256_lhs_w_17, sha256_lhs_w_18, sha256_lhs_w_19, sha256_lhs_w_3, sha256_lhs_w_7, sha256_maj, sha256_next_a_lhs, sha256_next_a_rhs, sha256_next_e_lhs, sha256_next_e_rhs, sha256_not_e, sha256_not_e_and_g, sha256_output_a_lhs, sha256_output_a_rhs, sha256_output_b_lhs, sha256_output_b_rhs, sha256_output_c_lhs, sha256_output_c_rhs, sha256_output_d_lhs, sha256_output_d_rhs, sha256_output_e_lhs, sha256_output_e_rhs, sha256_output_f_lhs, sha256_output_f_rhs, sha256_output_g_lhs, sha256_output_g_rhs, sha256_output_h_lhs, sha256_output_h_rhs, sha256_output_offset, sha256_perform_round, sha256_rhs_a_13, sha256_rhs_a_2, sha256_rhs_a_22, sha256_rhs_e_11, sha256_rhs_e_25, sha256_rhs_e_6, sha256_rhs_w_10, sha256_rhs_w_17, sha256_rhs_w_18, sha256_rhs_w_19, sha256_rhs_w_3, sha256_rhs_w_7, sha256_round_constant, sha256_round_count, sha256_rounds_remaining, sha256_rounds_remaining_inv, sha256_s_0, sha256_s_1, sha256_sel, sha256_start, sha256_state_offset, sha256_w, sha256_w_15_rotr_18, sha256_w_15_rotr_7, sha256_w_15_rotr_7_xor_w_15_rotr_18, sha256_w_15_rshift_3, sha256_w_2_rotr_17, sha256_w_2_rotr_17_xor_w_2_rotr_19, sha256_w_2_rotr_19, sha256_w_2_rshift_10, sha256_w_s_0, sha256_w_s_1, sha256_xor_sel, lookup_bytecode_bytes_are_bytes_counts, lookup_bytecode_to_read_unary_counts, lookup_rng_chk_pow_2_counts, lookup_rng_chk_diff_counts, lookup_rng_chk_is_r0_16_bit_counts, lookup_rng_chk_is_r1_16_bit_counts, lookup_rng_chk_is_r2_16_bit_counts, lookup_rng_chk_is_r3_16_bit_counts, lookup_rng_chk_is_r4_16_bit_counts, lookup_rng_chk_is_r5_16_bit_counts, lookup_rng_chk_is_r6_16_bit_counts, lookup_rng_chk_is_r7_16_bit_counts, lookup_bitw_byte_lengths_counts, lookup_bitw_byte_operations_counts, lookup_sha256_round_constant_counts, lookup_dummy_precomputed_counts, lookup_dummy_dynamic_counts -#define AVM2_DERIVED_WITNESS_ENTITIES perm_dummy_dynamic_inv, lookup_bytecode_bytes_are_bytes_inv, lookup_bytecode_to_read_unary_inv, lookup_rng_chk_pow_2_inv, lookup_rng_chk_diff_inv, lookup_rng_chk_is_r0_16_bit_inv, lookup_rng_chk_is_r1_16_bit_inv, lookup_rng_chk_is_r2_16_bit_inv, lookup_rng_chk_is_r3_16_bit_inv, lookup_rng_chk_is_r4_16_bit_inv, lookup_rng_chk_is_r5_16_bit_inv, lookup_rng_chk_is_r6_16_bit_inv, lookup_rng_chk_is_r7_16_bit_inv, lookup_bitw_byte_lengths_inv, lookup_bitw_byte_operations_inv, lookup_sha256_round_constant_inv, lookup_dummy_precomputed_inv, lookup_dummy_dynamic_inv -#define AVM2_SHIFTED_ENTITIES bc_decomposition_bytes_shift, bc_decomposition_bytes_pc_plus_1_shift, bc_decomposition_bytes_pc_plus_10_shift, bc_decomposition_bytes_pc_plus_11_shift, bc_decomposition_bytes_pc_plus_12_shift, bc_decomposition_bytes_pc_plus_13_shift, bc_decomposition_bytes_pc_plus_14_shift, bc_decomposition_bytes_pc_plus_15_shift, bc_decomposition_bytes_pc_plus_16_shift, bc_decomposition_bytes_pc_plus_17_shift, bc_decomposition_bytes_pc_plus_18_shift, bc_decomposition_bytes_pc_plus_19_shift, bc_decomposition_bytes_pc_plus_2_shift, bc_decomposition_bytes_pc_plus_20_shift, bc_decomposition_bytes_pc_plus_21_shift, bc_decomposition_bytes_pc_plus_22_shift, bc_decomposition_bytes_pc_plus_23_shift, bc_decomposition_bytes_pc_plus_24_shift, bc_decomposition_bytes_pc_plus_25_shift, bc_decomposition_bytes_pc_plus_26_shift, bc_decomposition_bytes_pc_plus_27_shift, bc_decomposition_bytes_pc_plus_28_shift, bc_decomposition_bytes_pc_plus_29_shift, bc_decomposition_bytes_pc_plus_3_shift, bc_decomposition_bytes_pc_plus_30_shift, bc_decomposition_bytes_pc_plus_31_shift, bc_decomposition_bytes_pc_plus_32_shift, bc_decomposition_bytes_pc_plus_33_shift, bc_decomposition_bytes_pc_plus_34_shift, bc_decomposition_bytes_pc_plus_4_shift, bc_decomposition_bytes_pc_plus_5_shift, bc_decomposition_bytes_pc_plus_6_shift, bc_decomposition_bytes_pc_plus_7_shift, bc_decomposition_bytes_pc_plus_8_shift, bc_decomposition_bytes_pc_plus_9_shift, bitwise_acc_ia_shift, bitwise_acc_ib_shift, bitwise_acc_ic_shift, bitwise_ctr_shift, bitwise_op_id_shift, execution_sel_shift, sha256_a_shift, sha256_b_shift, sha256_c_shift, sha256_d_shift, sha256_e_shift, sha256_f_shift, sha256_g_shift, sha256_h_shift, sha256_helper_w0_shift, sha256_helper_w1_shift, sha256_helper_w10_shift, sha256_helper_w11_shift, sha256_helper_w12_shift, sha256_helper_w13_shift, sha256_helper_w14_shift, sha256_helper_w15_shift, sha256_helper_w2_shift, sha256_helper_w3_shift, sha256_helper_w4_shift, sha256_helper_w5_shift, sha256_helper_w6_shift, sha256_helper_w7_shift, sha256_helper_w8_shift, sha256_helper_w9_shift, sha256_rounds_remaining_shift, sha256_sel_shift, sha256_start_shift -#define AVM2_TO_BE_SHIFTED(e) e.bc_decomposition_bytes, e.bc_decomposition_bytes_pc_plus_1, e.bc_decomposition_bytes_pc_plus_10, e.bc_decomposition_bytes_pc_plus_11, e.bc_decomposition_bytes_pc_plus_12, e.bc_decomposition_bytes_pc_plus_13, e.bc_decomposition_bytes_pc_plus_14, e.bc_decomposition_bytes_pc_plus_15, e.bc_decomposition_bytes_pc_plus_16, e.bc_decomposition_bytes_pc_plus_17, e.bc_decomposition_bytes_pc_plus_18, e.bc_decomposition_bytes_pc_plus_19, e.bc_decomposition_bytes_pc_plus_2, e.bc_decomposition_bytes_pc_plus_20, e.bc_decomposition_bytes_pc_plus_21, e.bc_decomposition_bytes_pc_plus_22, e.bc_decomposition_bytes_pc_plus_23, e.bc_decomposition_bytes_pc_plus_24, e.bc_decomposition_bytes_pc_plus_25, e.bc_decomposition_bytes_pc_plus_26, e.bc_decomposition_bytes_pc_plus_27, e.bc_decomposition_bytes_pc_plus_28, e.bc_decomposition_bytes_pc_plus_29, e.bc_decomposition_bytes_pc_plus_3, e.bc_decomposition_bytes_pc_plus_30, e.bc_decomposition_bytes_pc_plus_31, e.bc_decomposition_bytes_pc_plus_32, e.bc_decomposition_bytes_pc_plus_33, e.bc_decomposition_bytes_pc_plus_34, e.bc_decomposition_bytes_pc_plus_4, e.bc_decomposition_bytes_pc_plus_5, e.bc_decomposition_bytes_pc_plus_6, e.bc_decomposition_bytes_pc_plus_7, e.bc_decomposition_bytes_pc_plus_8, e.bc_decomposition_bytes_pc_plus_9, e.bitwise_acc_ia, e.bitwise_acc_ib, e.bitwise_acc_ic, e.bitwise_ctr, e.bitwise_op_id, e.execution_sel, e.sha256_a, e.sha256_b, e.sha256_c, e.sha256_d, e.sha256_e, e.sha256_f, e.sha256_g, e.sha256_h, e.sha256_helper_w0, e.sha256_helper_w1, e.sha256_helper_w10, e.sha256_helper_w11, e.sha256_helper_w12, e.sha256_helper_w13, e.sha256_helper_w14, e.sha256_helper_w15, e.sha256_helper_w2, e.sha256_helper_w3, e.sha256_helper_w4, e.sha256_helper_w5, e.sha256_helper_w6, e.sha256_helper_w7, e.sha256_helper_w8, e.sha256_helper_w9, e.sha256_rounds_remaining, e.sha256_sel, e.sha256_start +#define AVM2_WIRE_ENTITIES execution_input, alu_dst_addr, alu_ia, alu_ia_addr, alu_ib, alu_ib_addr, alu_ic, alu_op, alu_sel_op_add, bc_decomposition_abs_diff, bc_decomposition_bytes, bc_decomposition_bytes_pc_plus_1, bc_decomposition_bytes_pc_plus_10, bc_decomposition_bytes_pc_plus_11, bc_decomposition_bytes_pc_plus_12, bc_decomposition_bytes_pc_plus_13, bc_decomposition_bytes_pc_plus_14, bc_decomposition_bytes_pc_plus_15, bc_decomposition_bytes_pc_plus_16, bc_decomposition_bytes_pc_plus_17, bc_decomposition_bytes_pc_plus_18, bc_decomposition_bytes_pc_plus_19, bc_decomposition_bytes_pc_plus_2, bc_decomposition_bytes_pc_plus_20, bc_decomposition_bytes_pc_plus_21, bc_decomposition_bytes_pc_plus_22, bc_decomposition_bytes_pc_plus_23, bc_decomposition_bytes_pc_plus_24, bc_decomposition_bytes_pc_plus_25, bc_decomposition_bytes_pc_plus_26, bc_decomposition_bytes_pc_plus_27, bc_decomposition_bytes_pc_plus_28, bc_decomposition_bytes_pc_plus_29, bc_decomposition_bytes_pc_plus_3, bc_decomposition_bytes_pc_plus_30, bc_decomposition_bytes_pc_plus_31, bc_decomposition_bytes_pc_plus_32, bc_decomposition_bytes_pc_plus_33, bc_decomposition_bytes_pc_plus_34, bc_decomposition_bytes_pc_plus_35, bc_decomposition_bytes_pc_plus_4, bc_decomposition_bytes_pc_plus_5, bc_decomposition_bytes_pc_plus_6, bc_decomposition_bytes_pc_plus_7, bc_decomposition_bytes_pc_plus_8, bc_decomposition_bytes_pc_plus_9, bc_decomposition_bytes_rem_inv, bc_decomposition_bytes_rem_min_one_inv, bc_decomposition_bytes_remaining, bc_decomposition_bytes_to_read, bc_decomposition_bytes_to_read_unary, bc_decomposition_id, bc_decomposition_last_of_contract, bc_decomposition_pc, bc_decomposition_sel, bc_decomposition_sel_overflow_correction_needed, bc_decomposition_sel_pc_plus_1, bc_decomposition_sel_pc_plus_10, bc_decomposition_sel_pc_plus_11, bc_decomposition_sel_pc_plus_12, bc_decomposition_sel_pc_plus_13, bc_decomposition_sel_pc_plus_14, bc_decomposition_sel_pc_plus_15, bc_decomposition_sel_pc_plus_16, bc_decomposition_sel_pc_plus_17, bc_decomposition_sel_pc_plus_18, bc_decomposition_sel_pc_plus_19, bc_decomposition_sel_pc_plus_2, bc_decomposition_sel_pc_plus_20, bc_decomposition_sel_pc_plus_21, bc_decomposition_sel_pc_plus_22, bc_decomposition_sel_pc_plus_23, bc_decomposition_sel_pc_plus_24, bc_decomposition_sel_pc_plus_25, bc_decomposition_sel_pc_plus_26, bc_decomposition_sel_pc_plus_27, bc_decomposition_sel_pc_plus_28, bc_decomposition_sel_pc_plus_29, bc_decomposition_sel_pc_plus_3, bc_decomposition_sel_pc_plus_30, bc_decomposition_sel_pc_plus_31, bc_decomposition_sel_pc_plus_32, bc_decomposition_sel_pc_plus_33, bc_decomposition_sel_pc_plus_34, bc_decomposition_sel_pc_plus_35, bc_decomposition_sel_pc_plus_4, bc_decomposition_sel_pc_plus_5, bc_decomposition_sel_pc_plus_6, bc_decomposition_sel_pc_plus_7, bc_decomposition_sel_pc_plus_8, bc_decomposition_sel_pc_plus_9, bc_retrieval_address, bc_retrieval_artifact_hash, bc_retrieval_bytecode_id, bc_retrieval_class_id, bc_retrieval_deployer_addr, bc_retrieval_err, bc_retrieval_incoming_viewing_key_x, bc_retrieval_incoming_viewing_key_y, bc_retrieval_init_hash, bc_retrieval_nullifier_key_x, bc_retrieval_nullifier_key_y, bc_retrieval_outgoing_viewing_key_x, bc_retrieval_outgoing_viewing_key_y, bc_retrieval_private_function_root, bc_retrieval_public_bytecode_commitment, bc_retrieval_salt, bc_retrieval_sel, bc_retrieval_tagging_key_x, bc_retrieval_tagging_key_y, bitwise_acc_ia, bitwise_acc_ib, bitwise_acc_ic, bitwise_ctr, bitwise_ctr_inv, bitwise_ctr_min_one_inv, bitwise_ia_byte, bitwise_ib_byte, bitwise_ic_byte, bitwise_last, bitwise_op_id, bitwise_sel, bitwise_start, bitwise_tag, ecc_add_op, ecc_double_op, ecc_inv_2_p_y, ecc_inv_x_diff, ecc_inv_y_diff, ecc_lambda, ecc_p_is_inf, ecc_p_x, ecc_p_y, ecc_q_is_inf, ecc_q_x, ecc_q_y, ecc_r_is_inf, ecc_r_x, ecc_r_y, ecc_result_infinity, ecc_sel, ecc_x_match, ecc_y_match, execution_addressing_error_idx, execution_addressing_error_kind, execution_base_address_tag, execution_base_address_val, execution_bytecode_id, execution_clk, execution_ex_opcode, execution_indirect, execution_last, execution_op1, execution_op1_after_relative, execution_op2, execution_op2_after_relative, execution_op3, execution_op3_after_relative, execution_op4, execution_op4_after_relative, execution_pc, execution_rop1, execution_rop2, execution_rop3, execution_rop4, execution_sel, execution_sel_addressing_error, execution_sel_op1_is_address, execution_sel_op2_is_address, execution_sel_op3_is_address, execution_sel_op4_is_address, instr_fetching_bd0, instr_fetching_bd1, instr_fetching_bd10, instr_fetching_bd11, instr_fetching_bd12, instr_fetching_bd13, instr_fetching_bd14, instr_fetching_bd15, instr_fetching_bd16, instr_fetching_bd17, instr_fetching_bd18, instr_fetching_bd19, instr_fetching_bd2, instr_fetching_bd20, instr_fetching_bd21, instr_fetching_bd22, instr_fetching_bd23, instr_fetching_bd24, instr_fetching_bd25, instr_fetching_bd26, instr_fetching_bd27, instr_fetching_bd28, instr_fetching_bd29, instr_fetching_bd3, instr_fetching_bd30, instr_fetching_bd31, instr_fetching_bd32, instr_fetching_bd33, instr_fetching_bd34, instr_fetching_bd35, instr_fetching_bd4, instr_fetching_bd5, instr_fetching_bd6, instr_fetching_bd7, instr_fetching_bd8, instr_fetching_bd9, instr_fetching_bytecode_id, instr_fetching_ex_opcode, instr_fetching_fmt_3_op_u8, instr_fetching_indirect, instr_fetching_op1, instr_fetching_op2, instr_fetching_op3, instr_fetching_op4, instr_fetching_pc, instr_fetching_sel, range_check_dyn_diff, range_check_dyn_rng_chk_bits, range_check_dyn_rng_chk_pow_2, range_check_is_lte_u112, range_check_is_lte_u128, range_check_is_lte_u16, range_check_is_lte_u32, range_check_is_lte_u48, range_check_is_lte_u64, range_check_is_lte_u80, range_check_is_lte_u96, range_check_rng_chk_bits, range_check_sel, range_check_sel_r0_16_bit_rng_lookup, range_check_sel_r1_16_bit_rng_lookup, range_check_sel_r2_16_bit_rng_lookup, range_check_sel_r3_16_bit_rng_lookup, range_check_sel_r4_16_bit_rng_lookup, range_check_sel_r5_16_bit_rng_lookup, range_check_sel_r6_16_bit_rng_lookup, range_check_u16_r0, range_check_u16_r1, range_check_u16_r2, range_check_u16_r3, range_check_u16_r4, range_check_u16_r5, range_check_u16_r6, range_check_u16_r7, range_check_value, sha256_a, sha256_a_and_b, sha256_a_and_b_xor_a_and_c, sha256_a_and_c, sha256_a_rotr_13, sha256_a_rotr_2, sha256_a_rotr_22, sha256_a_rotr_2_xor_a_rotr_13, sha256_and_sel, sha256_b, sha256_b_and_c, sha256_c, sha256_ch, sha256_clk, sha256_computed_w_lhs, sha256_computed_w_rhs, sha256_d, sha256_dummy_zero, sha256_e, sha256_e_and_f, sha256_e_rotr_11, sha256_e_rotr_25, sha256_e_rotr_6, sha256_e_rotr_6_xor_e_rotr_11, sha256_f, sha256_g, sha256_h, sha256_helper_w0, sha256_helper_w1, sha256_helper_w10, sha256_helper_w11, sha256_helper_w12, sha256_helper_w13, sha256_helper_w14, sha256_helper_w15, sha256_helper_w2, sha256_helper_w3, sha256_helper_w4, sha256_helper_w5, sha256_helper_w6, sha256_helper_w7, sha256_helper_w8, sha256_helper_w9, sha256_init_a, sha256_init_b, sha256_init_c, sha256_init_d, sha256_init_e, sha256_init_f, sha256_init_g, sha256_init_h, sha256_input_offset, sha256_is_input_round, sha256_latch, sha256_lhs_a_13, sha256_lhs_a_2, sha256_lhs_a_22, sha256_lhs_e_11, sha256_lhs_e_25, sha256_lhs_e_6, sha256_lhs_w_10, sha256_lhs_w_17, sha256_lhs_w_18, sha256_lhs_w_19, sha256_lhs_w_3, sha256_lhs_w_7, sha256_maj, sha256_next_a_lhs, sha256_next_a_rhs, sha256_next_e_lhs, sha256_next_e_rhs, sha256_not_e, sha256_not_e_and_g, sha256_output_a_lhs, sha256_output_a_rhs, sha256_output_b_lhs, sha256_output_b_rhs, sha256_output_c_lhs, sha256_output_c_rhs, sha256_output_d_lhs, sha256_output_d_rhs, sha256_output_e_lhs, sha256_output_e_rhs, sha256_output_f_lhs, sha256_output_f_rhs, sha256_output_g_lhs, sha256_output_g_rhs, sha256_output_h_lhs, sha256_output_h_rhs, sha256_output_offset, sha256_perform_round, sha256_rhs_a_13, sha256_rhs_a_2, sha256_rhs_a_22, sha256_rhs_e_11, sha256_rhs_e_25, sha256_rhs_e_6, sha256_rhs_w_10, sha256_rhs_w_17, sha256_rhs_w_18, sha256_rhs_w_19, sha256_rhs_w_3, sha256_rhs_w_7, sha256_round_constant, sha256_round_count, sha256_rounds_remaining, sha256_rounds_remaining_inv, sha256_s_0, sha256_s_1, sha256_sel, sha256_start, sha256_state_offset, sha256_w, sha256_w_15_rotr_18, sha256_w_15_rotr_7, sha256_w_15_rotr_7_xor_w_15_rotr_18, sha256_w_15_rshift_3, sha256_w_2_rotr_17, sha256_w_2_rotr_17_xor_w_2_rotr_19, sha256_w_2_rotr_19, sha256_w_2_rshift_10, sha256_w_s_0, sha256_w_s_1, sha256_xor_sel, lookup_bytecode_bytes_are_bytes_counts, lookup_bytecode_remaining_abs_diff_u16_counts, lookup_bytecode_to_read_unary_counts, lookup_rng_chk_pow_2_counts, lookup_rng_chk_diff_counts, lookup_rng_chk_is_r0_16_bit_counts, lookup_rng_chk_is_r1_16_bit_counts, lookup_rng_chk_is_r2_16_bit_counts, lookup_rng_chk_is_r3_16_bit_counts, lookup_rng_chk_is_r4_16_bit_counts, lookup_rng_chk_is_r5_16_bit_counts, lookup_rng_chk_is_r6_16_bit_counts, lookup_rng_chk_is_r7_16_bit_counts, lookup_bitw_byte_lengths_counts, lookup_bitw_byte_operations_counts, lookup_sha256_round_constant_counts, lookup_dummy_precomputed_counts, lookup_dummy_dynamic_counts +#define AVM2_DERIVED_WITNESS_ENTITIES perm_dummy_dynamic_inv, lookup_bytecode_bytes_are_bytes_inv, lookup_bytecode_remaining_abs_diff_u16_inv, lookup_bytecode_to_read_unary_inv, lookup_rng_chk_pow_2_inv, lookup_rng_chk_diff_inv, lookup_rng_chk_is_r0_16_bit_inv, lookup_rng_chk_is_r1_16_bit_inv, lookup_rng_chk_is_r2_16_bit_inv, lookup_rng_chk_is_r3_16_bit_inv, lookup_rng_chk_is_r4_16_bit_inv, lookup_rng_chk_is_r5_16_bit_inv, lookup_rng_chk_is_r6_16_bit_inv, lookup_rng_chk_is_r7_16_bit_inv, lookup_bitw_byte_lengths_inv, lookup_bitw_byte_operations_inv, lookup_sha256_round_constant_inv, lookup_dummy_precomputed_inv, lookup_dummy_dynamic_inv +#define AVM2_SHIFTED_ENTITIES bc_decomposition_bytes_shift, bc_decomposition_bytes_pc_plus_1_shift, bc_decomposition_bytes_pc_plus_10_shift, bc_decomposition_bytes_pc_plus_11_shift, bc_decomposition_bytes_pc_plus_12_shift, bc_decomposition_bytes_pc_plus_13_shift, bc_decomposition_bytes_pc_plus_14_shift, bc_decomposition_bytes_pc_plus_15_shift, bc_decomposition_bytes_pc_plus_16_shift, bc_decomposition_bytes_pc_plus_17_shift, bc_decomposition_bytes_pc_plus_18_shift, bc_decomposition_bytes_pc_plus_19_shift, bc_decomposition_bytes_pc_plus_2_shift, bc_decomposition_bytes_pc_plus_20_shift, bc_decomposition_bytes_pc_plus_21_shift, bc_decomposition_bytes_pc_plus_22_shift, bc_decomposition_bytes_pc_plus_23_shift, bc_decomposition_bytes_pc_plus_24_shift, bc_decomposition_bytes_pc_plus_25_shift, bc_decomposition_bytes_pc_plus_26_shift, bc_decomposition_bytes_pc_plus_27_shift, bc_decomposition_bytes_pc_plus_28_shift, bc_decomposition_bytes_pc_plus_29_shift, bc_decomposition_bytes_pc_plus_3_shift, bc_decomposition_bytes_pc_plus_30_shift, bc_decomposition_bytes_pc_plus_31_shift, bc_decomposition_bytes_pc_plus_32_shift, bc_decomposition_bytes_pc_plus_33_shift, bc_decomposition_bytes_pc_plus_34_shift, bc_decomposition_bytes_pc_plus_4_shift, bc_decomposition_bytes_pc_plus_5_shift, bc_decomposition_bytes_pc_plus_6_shift, bc_decomposition_bytes_pc_plus_7_shift, bc_decomposition_bytes_pc_plus_8_shift, bc_decomposition_bytes_pc_plus_9_shift, bc_decomposition_bytes_remaining_shift, bc_decomposition_id_shift, bc_decomposition_pc_shift, bc_decomposition_sel_shift, bitwise_acc_ia_shift, bitwise_acc_ib_shift, bitwise_acc_ic_shift, bitwise_ctr_shift, bitwise_op_id_shift, execution_sel_shift, sha256_a_shift, sha256_b_shift, sha256_c_shift, sha256_d_shift, sha256_e_shift, sha256_f_shift, sha256_g_shift, sha256_h_shift, sha256_helper_w0_shift, sha256_helper_w1_shift, sha256_helper_w10_shift, sha256_helper_w11_shift, sha256_helper_w12_shift, sha256_helper_w13_shift, sha256_helper_w14_shift, sha256_helper_w15_shift, sha256_helper_w2_shift, sha256_helper_w3_shift, sha256_helper_w4_shift, sha256_helper_w5_shift, sha256_helper_w6_shift, sha256_helper_w7_shift, sha256_helper_w8_shift, sha256_helper_w9_shift, sha256_rounds_remaining_shift, sha256_sel_shift, sha256_start_shift +#define AVM2_TO_BE_SHIFTED(e) e.bc_decomposition_bytes, e.bc_decomposition_bytes_pc_plus_1, e.bc_decomposition_bytes_pc_plus_10, e.bc_decomposition_bytes_pc_plus_11, e.bc_decomposition_bytes_pc_plus_12, e.bc_decomposition_bytes_pc_plus_13, e.bc_decomposition_bytes_pc_plus_14, e.bc_decomposition_bytes_pc_plus_15, e.bc_decomposition_bytes_pc_plus_16, e.bc_decomposition_bytes_pc_plus_17, e.bc_decomposition_bytes_pc_plus_18, e.bc_decomposition_bytes_pc_plus_19, e.bc_decomposition_bytes_pc_plus_2, e.bc_decomposition_bytes_pc_plus_20, e.bc_decomposition_bytes_pc_plus_21, e.bc_decomposition_bytes_pc_plus_22, e.bc_decomposition_bytes_pc_plus_23, e.bc_decomposition_bytes_pc_plus_24, e.bc_decomposition_bytes_pc_plus_25, e.bc_decomposition_bytes_pc_plus_26, e.bc_decomposition_bytes_pc_plus_27, e.bc_decomposition_bytes_pc_plus_28, e.bc_decomposition_bytes_pc_plus_29, e.bc_decomposition_bytes_pc_plus_3, e.bc_decomposition_bytes_pc_plus_30, e.bc_decomposition_bytes_pc_plus_31, e.bc_decomposition_bytes_pc_plus_32, e.bc_decomposition_bytes_pc_plus_33, e.bc_decomposition_bytes_pc_plus_34, e.bc_decomposition_bytes_pc_plus_4, e.bc_decomposition_bytes_pc_plus_5, e.bc_decomposition_bytes_pc_plus_6, e.bc_decomposition_bytes_pc_plus_7, e.bc_decomposition_bytes_pc_plus_8, e.bc_decomposition_bytes_pc_plus_9, e.bc_decomposition_bytes_remaining, e.bc_decomposition_id, e.bc_decomposition_pc, e.bc_decomposition_sel, e.bitwise_acc_ia, e.bitwise_acc_ib, e.bitwise_acc_ic, e.bitwise_ctr, e.bitwise_op_id, e.execution_sel, e.sha256_a, e.sha256_b, e.sha256_c, e.sha256_d, e.sha256_e, e.sha256_f, e.sha256_g, e.sha256_h, e.sha256_helper_w0, e.sha256_helper_w1, e.sha256_helper_w10, e.sha256_helper_w11, e.sha256_helper_w12, e.sha256_helper_w13, e.sha256_helper_w14, e.sha256_helper_w15, e.sha256_helper_w2, e.sha256_helper_w3, e.sha256_helper_w4, e.sha256_helper_w5, e.sha256_helper_w6, e.sha256_helper_w7, e.sha256_helper_w8, e.sha256_helper_w9, e.sha256_rounds_remaining, e.sha256_sel, e.sha256_start #define AVM2_ALL_ENTITIES AVM2_PRECOMPUTED_ENTITIES, AVM2_WIRE_ENTITIES, AVM2_DERIVED_WITNESS_ENTITIES, AVM2_SHIFTED_ENTITIES #define AVM2_UNSHIFTED_ENTITIES AVM2_PRECOMPUTED_ENTITIES, AVM2_WIRE_ENTITIES, AVM2_DERIVED_WITNESS_ENTITIES #define AVM2_WITNESS_ENTITIES AVM2_WIRE_ENTITIES, AVM2_DERIVED_WITNESS_ENTITIES -#define AVM2_TO_BE_SHIFTED_COLUMNS Column::bc_decomposition_bytes, Column::bc_decomposition_bytes_pc_plus_1, Column::bc_decomposition_bytes_pc_plus_10, Column::bc_decomposition_bytes_pc_plus_11, Column::bc_decomposition_bytes_pc_plus_12, Column::bc_decomposition_bytes_pc_plus_13, Column::bc_decomposition_bytes_pc_plus_14, Column::bc_decomposition_bytes_pc_plus_15, Column::bc_decomposition_bytes_pc_plus_16, Column::bc_decomposition_bytes_pc_plus_17, Column::bc_decomposition_bytes_pc_plus_18, Column::bc_decomposition_bytes_pc_plus_19, Column::bc_decomposition_bytes_pc_plus_2, Column::bc_decomposition_bytes_pc_plus_20, Column::bc_decomposition_bytes_pc_plus_21, Column::bc_decomposition_bytes_pc_plus_22, Column::bc_decomposition_bytes_pc_plus_23, Column::bc_decomposition_bytes_pc_plus_24, Column::bc_decomposition_bytes_pc_plus_25, Column::bc_decomposition_bytes_pc_plus_26, Column::bc_decomposition_bytes_pc_plus_27, Column::bc_decomposition_bytes_pc_plus_28, Column::bc_decomposition_bytes_pc_plus_29, Column::bc_decomposition_bytes_pc_plus_3, Column::bc_decomposition_bytes_pc_plus_30, Column::bc_decomposition_bytes_pc_plus_31, Column::bc_decomposition_bytes_pc_plus_32, Column::bc_decomposition_bytes_pc_plus_33, Column::bc_decomposition_bytes_pc_plus_34, Column::bc_decomposition_bytes_pc_plus_4, Column::bc_decomposition_bytes_pc_plus_5, Column::bc_decomposition_bytes_pc_plus_6, Column::bc_decomposition_bytes_pc_plus_7, Column::bc_decomposition_bytes_pc_plus_8, Column::bc_decomposition_bytes_pc_plus_9, Column::bitwise_acc_ia, Column::bitwise_acc_ib, Column::bitwise_acc_ic, Column::bitwise_ctr, Column::bitwise_op_id, Column::execution_sel, Column::sha256_a, Column::sha256_b, Column::sha256_c, Column::sha256_d, Column::sha256_e, Column::sha256_f, Column::sha256_g, Column::sha256_h, Column::sha256_helper_w0, Column::sha256_helper_w1, Column::sha256_helper_w10, Column::sha256_helper_w11, Column::sha256_helper_w12, Column::sha256_helper_w13, Column::sha256_helper_w14, Column::sha256_helper_w15, Column::sha256_helper_w2, Column::sha256_helper_w3, Column::sha256_helper_w4, Column::sha256_helper_w5, Column::sha256_helper_w6, Column::sha256_helper_w7, Column::sha256_helper_w8, Column::sha256_helper_w9, Column::sha256_rounds_remaining, Column::sha256_sel, Column::sha256_start -#define AVM2_SHIFTED_COLUMNS ColumnAndShifts::bc_decomposition_bytes_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_1_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_10_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_11_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_12_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_13_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_14_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_15_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_16_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_17_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_18_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_19_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_2_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_20_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_21_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_22_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_23_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_24_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_25_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_26_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_27_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_28_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_29_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_3_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_30_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_31_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_32_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_33_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_34_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_4_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_5_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_6_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_7_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_8_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_9_shift, ColumnAndShifts::bitwise_acc_ia_shift, ColumnAndShifts::bitwise_acc_ib_shift, ColumnAndShifts::bitwise_acc_ic_shift, ColumnAndShifts::bitwise_ctr_shift, ColumnAndShifts::bitwise_op_id_shift, ColumnAndShifts::execution_sel_shift, ColumnAndShifts::sha256_a_shift, ColumnAndShifts::sha256_b_shift, ColumnAndShifts::sha256_c_shift, ColumnAndShifts::sha256_d_shift, ColumnAndShifts::sha256_e_shift, ColumnAndShifts::sha256_f_shift, ColumnAndShifts::sha256_g_shift, ColumnAndShifts::sha256_h_shift, ColumnAndShifts::sha256_helper_w0_shift, ColumnAndShifts::sha256_helper_w1_shift, ColumnAndShifts::sha256_helper_w10_shift, ColumnAndShifts::sha256_helper_w11_shift, ColumnAndShifts::sha256_helper_w12_shift, ColumnAndShifts::sha256_helper_w13_shift, ColumnAndShifts::sha256_helper_w14_shift, ColumnAndShifts::sha256_helper_w15_shift, ColumnAndShifts::sha256_helper_w2_shift, ColumnAndShifts::sha256_helper_w3_shift, ColumnAndShifts::sha256_helper_w4_shift, ColumnAndShifts::sha256_helper_w5_shift, ColumnAndShifts::sha256_helper_w6_shift, ColumnAndShifts::sha256_helper_w7_shift, ColumnAndShifts::sha256_helper_w8_shift, ColumnAndShifts::sha256_helper_w9_shift, ColumnAndShifts::sha256_rounds_remaining_shift, ColumnAndShifts::sha256_sel_shift, ColumnAndShifts::sha256_start_shift +#define AVM2_TO_BE_SHIFTED_COLUMNS Column::bc_decomposition_bytes, Column::bc_decomposition_bytes_pc_plus_1, Column::bc_decomposition_bytes_pc_plus_10, Column::bc_decomposition_bytes_pc_plus_11, Column::bc_decomposition_bytes_pc_plus_12, Column::bc_decomposition_bytes_pc_plus_13, Column::bc_decomposition_bytes_pc_plus_14, Column::bc_decomposition_bytes_pc_plus_15, Column::bc_decomposition_bytes_pc_plus_16, Column::bc_decomposition_bytes_pc_plus_17, Column::bc_decomposition_bytes_pc_plus_18, Column::bc_decomposition_bytes_pc_plus_19, Column::bc_decomposition_bytes_pc_plus_2, Column::bc_decomposition_bytes_pc_plus_20, Column::bc_decomposition_bytes_pc_plus_21, Column::bc_decomposition_bytes_pc_plus_22, Column::bc_decomposition_bytes_pc_plus_23, Column::bc_decomposition_bytes_pc_plus_24, Column::bc_decomposition_bytes_pc_plus_25, Column::bc_decomposition_bytes_pc_plus_26, Column::bc_decomposition_bytes_pc_plus_27, Column::bc_decomposition_bytes_pc_plus_28, Column::bc_decomposition_bytes_pc_plus_29, Column::bc_decomposition_bytes_pc_plus_3, Column::bc_decomposition_bytes_pc_plus_30, Column::bc_decomposition_bytes_pc_plus_31, Column::bc_decomposition_bytes_pc_plus_32, Column::bc_decomposition_bytes_pc_plus_33, Column::bc_decomposition_bytes_pc_plus_34, Column::bc_decomposition_bytes_pc_plus_4, Column::bc_decomposition_bytes_pc_plus_5, Column::bc_decomposition_bytes_pc_plus_6, Column::bc_decomposition_bytes_pc_plus_7, Column::bc_decomposition_bytes_pc_plus_8, Column::bc_decomposition_bytes_pc_plus_9, Column::bc_decomposition_bytes_remaining, Column::bc_decomposition_id, Column::bc_decomposition_pc, Column::bc_decomposition_sel, Column::bitwise_acc_ia, Column::bitwise_acc_ib, Column::bitwise_acc_ic, Column::bitwise_ctr, Column::bitwise_op_id, Column::execution_sel, Column::sha256_a, Column::sha256_b, Column::sha256_c, Column::sha256_d, Column::sha256_e, Column::sha256_f, Column::sha256_g, Column::sha256_h, Column::sha256_helper_w0, Column::sha256_helper_w1, Column::sha256_helper_w10, Column::sha256_helper_w11, Column::sha256_helper_w12, Column::sha256_helper_w13, Column::sha256_helper_w14, Column::sha256_helper_w15, Column::sha256_helper_w2, Column::sha256_helper_w3, Column::sha256_helper_w4, Column::sha256_helper_w5, Column::sha256_helper_w6, Column::sha256_helper_w7, Column::sha256_helper_w8, Column::sha256_helper_w9, Column::sha256_rounds_remaining, Column::sha256_sel, Column::sha256_start +#define AVM2_SHIFTED_COLUMNS ColumnAndShifts::bc_decomposition_bytes_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_1_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_10_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_11_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_12_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_13_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_14_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_15_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_16_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_17_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_18_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_19_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_2_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_20_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_21_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_22_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_23_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_24_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_25_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_26_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_27_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_28_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_29_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_3_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_30_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_31_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_32_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_33_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_34_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_4_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_5_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_6_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_7_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_8_shift, ColumnAndShifts::bc_decomposition_bytes_pc_plus_9_shift, ColumnAndShifts::bc_decomposition_bytes_remaining_shift, ColumnAndShifts::bc_decomposition_id_shift, ColumnAndShifts::bc_decomposition_pc_shift, ColumnAndShifts::bc_decomposition_sel_shift, ColumnAndShifts::bitwise_acc_ia_shift, ColumnAndShifts::bitwise_acc_ib_shift, ColumnAndShifts::bitwise_acc_ic_shift, ColumnAndShifts::bitwise_ctr_shift, ColumnAndShifts::bitwise_op_id_shift, ColumnAndShifts::execution_sel_shift, ColumnAndShifts::sha256_a_shift, ColumnAndShifts::sha256_b_shift, ColumnAndShifts::sha256_c_shift, ColumnAndShifts::sha256_d_shift, ColumnAndShifts::sha256_e_shift, ColumnAndShifts::sha256_f_shift, ColumnAndShifts::sha256_g_shift, ColumnAndShifts::sha256_h_shift, ColumnAndShifts::sha256_helper_w0_shift, ColumnAndShifts::sha256_helper_w1_shift, ColumnAndShifts::sha256_helper_w10_shift, ColumnAndShifts::sha256_helper_w11_shift, ColumnAndShifts::sha256_helper_w12_shift, ColumnAndShifts::sha256_helper_w13_shift, ColumnAndShifts::sha256_helper_w14_shift, ColumnAndShifts::sha256_helper_w15_shift, ColumnAndShifts::sha256_helper_w2_shift, ColumnAndShifts::sha256_helper_w3_shift, ColumnAndShifts::sha256_helper_w4_shift, ColumnAndShifts::sha256_helper_w5_shift, ColumnAndShifts::sha256_helper_w6_shift, ColumnAndShifts::sha256_helper_w7_shift, ColumnAndShifts::sha256_helper_w8_shift, ColumnAndShifts::sha256_helper_w9_shift, ColumnAndShifts::sha256_rounds_remaining_shift, ColumnAndShifts::sha256_sel_shift, ColumnAndShifts::sha256_start_shift // clang-format on // All columns minus shifts. @@ -31,8 +31,8 @@ enum class ColumnAndShifts { SENTINEL_DO_NOT_USE, }; -constexpr auto NUM_COLUMNS_WITH_SHIFTS = 487; -constexpr auto NUM_COLUMNS_WITHOUT_SHIFTS = 419; +constexpr auto NUM_COLUMNS_WITH_SHIFTS = 495; +constexpr auto NUM_COLUMNS_WITHOUT_SHIFTS = 423; constexpr auto TO_BE_SHIFTED_COLUMNS_ARRAY = []() { return std::array{ AVM2_TO_BE_SHIFTED_COLUMNS }; }(); constexpr auto SHIFTED_COLUMNS_ARRAY = []() { return std::array{ AVM2_SHIFTED_COLUMNS }; }(); static_assert(TO_BE_SHIFTED_COLUMNS_ARRAY.size() == SHIFTED_COLUMNS_ARRAY.size()); diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.hpp index 5b53fb797c56..ce332646db47 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.hpp @@ -77,12 +77,12 @@ class AvmFlavor { static constexpr bool HasZK = false; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 16; - static constexpr size_t NUM_WITNESS_ENTITIES = 403; - static constexpr size_t NUM_SHIFTED_ENTITIES = 68; + static constexpr size_t NUM_WITNESS_ENTITIES = 407; + static constexpr size_t NUM_SHIFTED_ENTITIES = 72; static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES; // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for // the unshifted and one for the shifted - static constexpr size_t NUM_ALL_ENTITIES = 487; + static constexpr size_t NUM_ALL_ENTITIES = 495; // Need to be templated for recursive verifier template @@ -107,6 +107,7 @@ class AvmFlavor { lookup_bitw_byte_lengths_relation, lookup_bitw_byte_operations_relation, lookup_bytecode_bytes_are_bytes_relation, + lookup_bytecode_remaining_abs_diff_u16_relation, lookup_bytecode_to_read_unary_relation, lookup_dummy_dynamic_relation, lookup_dummy_precomputed_relation, diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_decomposition.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_decomposition.hpp index 94e2a741f100..aaf2b0ca24b7 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_decomposition.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_decomposition.hpp @@ -12,9 +12,11 @@ template class bc_decompositionImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 }; + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { + 3, 3, 4, 4, 5, 3, 4, 4, 4, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 + }; template inline static bool skip(const AllEntities& in) { @@ -32,313 +34,597 @@ template class bc_decompositionImpl { { using Accumulator = typename std::tuple_element_t<0, ContainerOverSubrelations>; - auto tmp = - new_term.bc_decomposition_last_of_contract * (FF(1) - new_term.bc_decomposition_last_of_contract); + auto tmp = new_term.bc_decomposition_sel * (FF(1) - new_term.bc_decomposition_sel); tmp *= scaling_factor; std::get<0>(evals) += typename Accumulator::View(tmp); } { using Accumulator = typename std::tuple_element_t<1, ContainerOverSubrelations>; - auto tmp = new_term.bc_decomposition_sel_overflow_correction_needed * - (FF(1) - new_term.bc_decomposition_sel_overflow_correction_needed); + auto tmp = + new_term.bc_decomposition_last_of_contract * (FF(1) - new_term.bc_decomposition_last_of_contract); tmp *= scaling_factor; std::get<1>(evals) += typename Accumulator::View(tmp); } { using Accumulator = typename std::tuple_element_t<2, ContainerOverSubrelations>; + auto tmp = + (new_term.bc_decomposition_bytes_remaining * + ((FF(1) - new_term.bc_decomposition_sel) * (FF(1) - new_term.bc_decomposition_bytes_rem_inv) + + new_term.bc_decomposition_bytes_rem_inv) - + new_term.bc_decomposition_sel); + tmp *= scaling_factor; + std::get<2>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<3, ContainerOverSubrelations>; + auto tmp = (FF(1) - new_term.precomputed_first_row) * (FF(1) - new_term.bc_decomposition_sel) * + new_term.bc_decomposition_sel_shift; + tmp *= scaling_factor; + std::get<3>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<4, ContainerOverSubrelations>; + auto tmp = + new_term.bc_decomposition_sel * (((new_term.bc_decomposition_bytes_remaining - FF(1)) * + (new_term.bc_decomposition_last_of_contract * + (FF(1) - new_term.bc_decomposition_bytes_rem_min_one_inv) + + new_term.bc_decomposition_bytes_rem_min_one_inv) + + new_term.bc_decomposition_last_of_contract) - + FF(1)); + tmp *= scaling_factor; + std::get<4>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<5, ContainerOverSubrelations>; + auto tmp = (new_term.precomputed_first_row + new_term.bc_decomposition_last_of_contract) * + new_term.bc_decomposition_pc_shift; + tmp *= scaling_factor; + std::get<5>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<6, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel * (FF(1) - new_term.bc_decomposition_last_of_contract) * + ((new_term.bc_decomposition_pc_shift - new_term.bc_decomposition_pc) - FF(1)); + tmp *= scaling_factor; + std::get<6>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<7, ContainerOverSubrelations>; + auto tmp = + new_term.bc_decomposition_sel * (FF(1) - new_term.bc_decomposition_last_of_contract) * + ((new_term.bc_decomposition_bytes_remaining_shift - new_term.bc_decomposition_bytes_remaining) + FF(1)); + tmp *= scaling_factor; + std::get<7>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<8, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel * (FF(1) - new_term.bc_decomposition_last_of_contract) * + (new_term.bc_decomposition_id_shift - new_term.bc_decomposition_id); + tmp *= scaling_factor; + std::get<8>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<9, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_overflow_correction_needed * + (FF(1) - new_term.bc_decomposition_sel_overflow_correction_needed); + tmp *= scaling_factor; + std::get<9>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<10, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel * + (((FF(2) * new_term.bc_decomposition_sel_overflow_correction_needed * + (bc_decomposition_WINDOW_SIZE - new_term.bc_decomposition_bytes_remaining) - + bc_decomposition_WINDOW_SIZE) + + new_term.bc_decomposition_bytes_remaining) - + new_term.bc_decomposition_abs_diff); + tmp *= scaling_factor; + std::get<10>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<11, ContainerOverSubrelations>; auto tmp = new_term.bc_decomposition_sel * ((FF(1) - new_term.bc_decomposition_sel_overflow_correction_needed) * (new_term.bc_decomposition_bytes_to_read - bc_decomposition_WINDOW_SIZE) + new_term.bc_decomposition_sel_overflow_correction_needed * (new_term.bc_decomposition_bytes_to_read - new_term.bc_decomposition_bytes_remaining)); tmp *= scaling_factor; - std::get<2>(evals) += typename Accumulator::View(tmp); + std::get<11>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<3, ContainerOverSubrelations>; - auto tmp = (new_term.bc_decomposition_bytes_to_read_unary - - new_term.bc_decomposition_sel * (FF(1) + new_term.bc_decomposition_sel_pc_plus_1 * FF(2) + - new_term.bc_decomposition_sel_pc_plus_2 * FF(4) + - new_term.bc_decomposition_sel_pc_plus_3 * FF(8) + - new_term.bc_decomposition_sel_pc_plus_4 * FF(16) + - new_term.bc_decomposition_sel_pc_plus_5 * FF(32) + - new_term.bc_decomposition_sel_pc_plus_6 * FF(64) + - new_term.bc_decomposition_sel_pc_plus_7 * FF(128) + - new_term.bc_decomposition_sel_pc_plus_8 * FF(256) + - new_term.bc_decomposition_sel_pc_plus_9 * FF(512) + - new_term.bc_decomposition_sel_pc_plus_10 * FF(1024) + - new_term.bc_decomposition_sel_pc_plus_11 * FF(2048) + - new_term.bc_decomposition_sel_pc_plus_12 * FF(4096) + - new_term.bc_decomposition_sel_pc_plus_13 * FF(8192) + - new_term.bc_decomposition_sel_pc_plus_14 * FF(16384) + - new_term.bc_decomposition_sel_pc_plus_15 * FF(32768) + - new_term.bc_decomposition_sel_pc_plus_16 * FF(65536) + - new_term.bc_decomposition_sel_pc_plus_17 * FF(131072) + - new_term.bc_decomposition_sel_pc_plus_18 * FF(262144) + - new_term.bc_decomposition_sel_pc_plus_19 * FF(524288) + - new_term.bc_decomposition_sel_pc_plus_20 * FF(1048576) + - new_term.bc_decomposition_sel_pc_plus_21 * FF(2097152) + - new_term.bc_decomposition_sel_pc_plus_22 * FF(4194304) + - new_term.bc_decomposition_sel_pc_plus_23 * FF(8388608) + - new_term.bc_decomposition_sel_pc_plus_24 * FF(16777216) + - new_term.bc_decomposition_sel_pc_plus_25 * FF(33554432) + - new_term.bc_decomposition_sel_pc_plus_26 * FF(67108864) + - new_term.bc_decomposition_sel_pc_plus_27 * FF(134217728) + - new_term.bc_decomposition_sel_pc_plus_28 * FF(268435456) + - new_term.bc_decomposition_sel_pc_plus_29 * FF(536870912) + - new_term.bc_decomposition_sel_pc_plus_30 * FF(1073741824) + - new_term.bc_decomposition_sel_pc_plus_31 * FF(2147483648UL) + - new_term.bc_decomposition_sel_pc_plus_32 * FF(4294967296UL) + - new_term.bc_decomposition_sel_pc_plus_33 * FF(8589934592UL) + - new_term.bc_decomposition_sel_pc_plus_34 * FF(17179869184UL) + - new_term.bc_decomposition_sel_pc_plus_35 * FF(34359738368UL))); + using Accumulator = typename std::tuple_element_t<12, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_1 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_1); tmp *= scaling_factor; - std::get<3>(evals) += typename Accumulator::View(tmp); + std::get<12>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<4, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<13, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_2 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_2); + tmp *= scaling_factor; + std::get<13>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<14, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_3 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_3); + tmp *= scaling_factor; + std::get<14>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<15, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_4 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_4); + tmp *= scaling_factor; + std::get<15>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<16, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_5 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_5); + tmp *= scaling_factor; + std::get<16>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<17, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_6 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_6); + tmp *= scaling_factor; + std::get<17>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<18, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_7 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_7); + tmp *= scaling_factor; + std::get<18>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<19, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_8 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_8); + tmp *= scaling_factor; + std::get<19>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<20, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_9 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_9); + tmp *= scaling_factor; + std::get<20>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<21, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_10 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_10); + tmp *= scaling_factor; + std::get<21>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<22, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_11 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_11); + tmp *= scaling_factor; + std::get<22>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<23, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_12 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_12); + tmp *= scaling_factor; + std::get<23>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<24, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_13 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_13); + tmp *= scaling_factor; + std::get<24>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<25, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_14 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_14); + tmp *= scaling_factor; + std::get<25>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<26, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_15 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_15); + tmp *= scaling_factor; + std::get<26>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<27, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_16 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_16); + tmp *= scaling_factor; + std::get<27>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<28, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_17 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_17); + tmp *= scaling_factor; + std::get<28>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<29, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_18 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_18); + tmp *= scaling_factor; + std::get<29>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<30, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_19 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_19); + tmp *= scaling_factor; + std::get<30>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<31, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_20 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_20); + tmp *= scaling_factor; + std::get<31>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<32, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_21 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_21); + tmp *= scaling_factor; + std::get<32>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<33, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_22 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_22); + tmp *= scaling_factor; + std::get<33>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<34, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_23 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_23); + tmp *= scaling_factor; + std::get<34>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<35, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_24 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_24); + tmp *= scaling_factor; + std::get<35>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<36, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_25 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_25); + tmp *= scaling_factor; + std::get<36>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<37, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_26 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_26); + tmp *= scaling_factor; + std::get<37>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<38, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_27 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_27); + tmp *= scaling_factor; + std::get<38>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<39, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_28 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_28); + tmp *= scaling_factor; + std::get<39>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<40, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_29 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_29); + tmp *= scaling_factor; + std::get<40>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<41, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_30 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_30); + tmp *= scaling_factor; + std::get<41>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<42, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_31 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_31); + tmp *= scaling_factor; + std::get<42>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<43, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_32 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_32); + tmp *= scaling_factor; + std::get<43>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<44, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_33 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_33); + tmp *= scaling_factor; + std::get<44>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<45, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_34 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_34); + tmp *= scaling_factor; + std::get<45>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<46, ContainerOverSubrelations>; + auto tmp = new_term.bc_decomposition_sel_pc_plus_35 * (FF(1) - new_term.bc_decomposition_sel_pc_plus_35); + tmp *= scaling_factor; + std::get<46>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<47, ContainerOverSubrelations>; + auto tmp = + new_term.bc_decomposition_sel * + ((FF(1) + new_term.bc_decomposition_sel_pc_plus_1 * FF(2) + + new_term.bc_decomposition_sel_pc_plus_2 * FF(4) + new_term.bc_decomposition_sel_pc_plus_3 * FF(8) + + new_term.bc_decomposition_sel_pc_plus_4 * FF(16) + new_term.bc_decomposition_sel_pc_plus_5 * FF(32) + + new_term.bc_decomposition_sel_pc_plus_6 * FF(64) + new_term.bc_decomposition_sel_pc_plus_7 * FF(128) + + new_term.bc_decomposition_sel_pc_plus_8 * FF(256) + + new_term.bc_decomposition_sel_pc_plus_9 * FF(512) + + new_term.bc_decomposition_sel_pc_plus_10 * FF(1024) + + new_term.bc_decomposition_sel_pc_plus_11 * FF(2048) + + new_term.bc_decomposition_sel_pc_plus_12 * FF(4096) + + new_term.bc_decomposition_sel_pc_plus_13 * FF(8192) + + new_term.bc_decomposition_sel_pc_plus_14 * FF(16384) + + new_term.bc_decomposition_sel_pc_plus_15 * FF(32768) + + new_term.bc_decomposition_sel_pc_plus_16 * FF(65536) + + new_term.bc_decomposition_sel_pc_plus_17 * FF(131072) + + new_term.bc_decomposition_sel_pc_plus_18 * FF(262144) + + new_term.bc_decomposition_sel_pc_plus_19 * FF(524288) + + new_term.bc_decomposition_sel_pc_plus_20 * FF(1048576) + + new_term.bc_decomposition_sel_pc_plus_21 * FF(2097152) + + new_term.bc_decomposition_sel_pc_plus_22 * FF(4194304) + + new_term.bc_decomposition_sel_pc_plus_23 * FF(8388608) + + new_term.bc_decomposition_sel_pc_plus_24 * FF(16777216) + + new_term.bc_decomposition_sel_pc_plus_25 * FF(33554432) + + new_term.bc_decomposition_sel_pc_plus_26 * FF(67108864) + + new_term.bc_decomposition_sel_pc_plus_27 * FF(134217728) + + new_term.bc_decomposition_sel_pc_plus_28 * FF(268435456) + + new_term.bc_decomposition_sel_pc_plus_29 * FF(536870912) + + new_term.bc_decomposition_sel_pc_plus_30 * FF(1073741824) + + new_term.bc_decomposition_sel_pc_plus_31 * FF(2147483648UL) + + new_term.bc_decomposition_sel_pc_plus_32 * FF(4294967296UL) + + new_term.bc_decomposition_sel_pc_plus_33 * FF(8589934592UL) + + new_term.bc_decomposition_sel_pc_plus_34 * FF(17179869184UL) + + new_term.bc_decomposition_sel_pc_plus_35 * FF(34359738368UL)) - + new_term.bc_decomposition_bytes_to_read_unary); + tmp *= scaling_factor; + std::get<47>(evals) += typename Accumulator::View(tmp); + } + { + using Accumulator = typename std::tuple_element_t<48, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_1 - new_term.bc_decomposition_sel_pc_plus_1 * new_term.bc_decomposition_bytes_shift); tmp *= scaling_factor; - std::get<4>(evals) += typename Accumulator::View(tmp); + std::get<48>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<5, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<49, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_2 - new_term.bc_decomposition_sel_pc_plus_2 * new_term.bc_decomposition_bytes_pc_plus_1_shift); tmp *= scaling_factor; - std::get<5>(evals) += typename Accumulator::View(tmp); + std::get<49>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<6, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<50, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_3 - new_term.bc_decomposition_sel_pc_plus_3 * new_term.bc_decomposition_bytes_pc_plus_2_shift); tmp *= scaling_factor; - std::get<6>(evals) += typename Accumulator::View(tmp); + std::get<50>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<7, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<51, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_4 - new_term.bc_decomposition_sel_pc_plus_4 * new_term.bc_decomposition_bytes_pc_plus_3_shift); tmp *= scaling_factor; - std::get<7>(evals) += typename Accumulator::View(tmp); + std::get<51>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<8, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<52, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_5 - new_term.bc_decomposition_sel_pc_plus_5 * new_term.bc_decomposition_bytes_pc_plus_4_shift); tmp *= scaling_factor; - std::get<8>(evals) += typename Accumulator::View(tmp); + std::get<52>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<9, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<53, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_6 - new_term.bc_decomposition_sel_pc_plus_6 * new_term.bc_decomposition_bytes_pc_plus_5_shift); tmp *= scaling_factor; - std::get<9>(evals) += typename Accumulator::View(tmp); + std::get<53>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<10, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<54, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_7 - new_term.bc_decomposition_sel_pc_plus_7 * new_term.bc_decomposition_bytes_pc_plus_6_shift); tmp *= scaling_factor; - std::get<10>(evals) += typename Accumulator::View(tmp); + std::get<54>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<11, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<55, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_8 - new_term.bc_decomposition_sel_pc_plus_8 * new_term.bc_decomposition_bytes_pc_plus_7_shift); tmp *= scaling_factor; - std::get<11>(evals) += typename Accumulator::View(tmp); + std::get<55>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<12, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<56, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_9 - new_term.bc_decomposition_sel_pc_plus_9 * new_term.bc_decomposition_bytes_pc_plus_8_shift); tmp *= scaling_factor; - std::get<12>(evals) += typename Accumulator::View(tmp); + std::get<56>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<13, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<57, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_10 - new_term.bc_decomposition_sel_pc_plus_10 * new_term.bc_decomposition_bytes_pc_plus_9_shift); tmp *= scaling_factor; - std::get<13>(evals) += typename Accumulator::View(tmp); + std::get<57>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<14, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<58, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_11 - new_term.bc_decomposition_sel_pc_plus_11 * new_term.bc_decomposition_bytes_pc_plus_10_shift); tmp *= scaling_factor; - std::get<14>(evals) += typename Accumulator::View(tmp); + std::get<58>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<15, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<59, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_12 - new_term.bc_decomposition_sel_pc_plus_12 * new_term.bc_decomposition_bytes_pc_plus_11_shift); tmp *= scaling_factor; - std::get<15>(evals) += typename Accumulator::View(tmp); + std::get<59>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<16, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<60, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_13 - new_term.bc_decomposition_sel_pc_plus_13 * new_term.bc_decomposition_bytes_pc_plus_12_shift); tmp *= scaling_factor; - std::get<16>(evals) += typename Accumulator::View(tmp); + std::get<60>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<17, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<61, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_14 - new_term.bc_decomposition_sel_pc_plus_14 * new_term.bc_decomposition_bytes_pc_plus_13_shift); tmp *= scaling_factor; - std::get<17>(evals) += typename Accumulator::View(tmp); + std::get<61>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<18, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<62, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_15 - new_term.bc_decomposition_sel_pc_plus_15 * new_term.bc_decomposition_bytes_pc_plus_14_shift); tmp *= scaling_factor; - std::get<18>(evals) += typename Accumulator::View(tmp); + std::get<62>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<19, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<63, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_16 - new_term.bc_decomposition_sel_pc_plus_16 * new_term.bc_decomposition_bytes_pc_plus_15_shift); tmp *= scaling_factor; - std::get<19>(evals) += typename Accumulator::View(tmp); + std::get<63>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<20, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<64, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_17 - new_term.bc_decomposition_sel_pc_plus_17 * new_term.bc_decomposition_bytes_pc_plus_16_shift); tmp *= scaling_factor; - std::get<20>(evals) += typename Accumulator::View(tmp); + std::get<64>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<21, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<65, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_18 - new_term.bc_decomposition_sel_pc_plus_18 * new_term.bc_decomposition_bytes_pc_plus_17_shift); tmp *= scaling_factor; - std::get<21>(evals) += typename Accumulator::View(tmp); + std::get<65>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<22, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<66, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_19 - new_term.bc_decomposition_sel_pc_plus_19 * new_term.bc_decomposition_bytes_pc_plus_18_shift); tmp *= scaling_factor; - std::get<22>(evals) += typename Accumulator::View(tmp); + std::get<66>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<23, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<67, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_20 - new_term.bc_decomposition_sel_pc_plus_20 * new_term.bc_decomposition_bytes_pc_plus_19_shift); tmp *= scaling_factor; - std::get<23>(evals) += typename Accumulator::View(tmp); + std::get<67>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<24, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<68, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_21 - new_term.bc_decomposition_sel_pc_plus_21 * new_term.bc_decomposition_bytes_pc_plus_20_shift); tmp *= scaling_factor; - std::get<24>(evals) += typename Accumulator::View(tmp); + std::get<68>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<25, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<69, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_22 - new_term.bc_decomposition_sel_pc_plus_22 * new_term.bc_decomposition_bytes_pc_plus_21_shift); tmp *= scaling_factor; - std::get<25>(evals) += typename Accumulator::View(tmp); + std::get<69>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<26, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<70, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_23 - new_term.bc_decomposition_sel_pc_plus_23 * new_term.bc_decomposition_bytes_pc_plus_22_shift); tmp *= scaling_factor; - std::get<26>(evals) += typename Accumulator::View(tmp); + std::get<70>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<27, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<71, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_24 - new_term.bc_decomposition_sel_pc_plus_24 * new_term.bc_decomposition_bytes_pc_plus_23_shift); tmp *= scaling_factor; - std::get<27>(evals) += typename Accumulator::View(tmp); + std::get<71>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<28, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<72, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_25 - new_term.bc_decomposition_sel_pc_plus_25 * new_term.bc_decomposition_bytes_pc_plus_24_shift); tmp *= scaling_factor; - std::get<28>(evals) += typename Accumulator::View(tmp); + std::get<72>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<29, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<73, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_26 - new_term.bc_decomposition_sel_pc_plus_26 * new_term.bc_decomposition_bytes_pc_plus_25_shift); tmp *= scaling_factor; - std::get<29>(evals) += typename Accumulator::View(tmp); + std::get<73>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<30, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<74, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_27 - new_term.bc_decomposition_sel_pc_plus_27 * new_term.bc_decomposition_bytes_pc_plus_26_shift); tmp *= scaling_factor; - std::get<30>(evals) += typename Accumulator::View(tmp); + std::get<74>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<31, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<75, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_28 - new_term.bc_decomposition_sel_pc_plus_28 * new_term.bc_decomposition_bytes_pc_plus_27_shift); tmp *= scaling_factor; - std::get<31>(evals) += typename Accumulator::View(tmp); + std::get<75>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<32, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<76, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_29 - new_term.bc_decomposition_sel_pc_plus_29 * new_term.bc_decomposition_bytes_pc_plus_28_shift); tmp *= scaling_factor; - std::get<32>(evals) += typename Accumulator::View(tmp); + std::get<76>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<33, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<77, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_30 - new_term.bc_decomposition_sel_pc_plus_30 * new_term.bc_decomposition_bytes_pc_plus_29_shift); tmp *= scaling_factor; - std::get<33>(evals) += typename Accumulator::View(tmp); + std::get<77>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<34, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<78, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_31 - new_term.bc_decomposition_sel_pc_plus_31 * new_term.bc_decomposition_bytes_pc_plus_30_shift); tmp *= scaling_factor; - std::get<34>(evals) += typename Accumulator::View(tmp); + std::get<78>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<35, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<79, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_32 - new_term.bc_decomposition_sel_pc_plus_32 * new_term.bc_decomposition_bytes_pc_plus_31_shift); tmp *= scaling_factor; - std::get<35>(evals) += typename Accumulator::View(tmp); + std::get<79>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<36, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<80, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_33 - new_term.bc_decomposition_sel_pc_plus_33 * new_term.bc_decomposition_bytes_pc_plus_32_shift); tmp *= scaling_factor; - std::get<36>(evals) += typename Accumulator::View(tmp); + std::get<80>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<37, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<81, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_34 - new_term.bc_decomposition_sel_pc_plus_34 * new_term.bc_decomposition_bytes_pc_plus_33_shift); tmp *= scaling_factor; - std::get<37>(evals) += typename Accumulator::View(tmp); + std::get<81>(evals) += typename Accumulator::View(tmp); } { - using Accumulator = typename std::tuple_element_t<38, ContainerOverSubrelations>; + using Accumulator = typename std::tuple_element_t<82, ContainerOverSubrelations>; auto tmp = (new_term.bc_decomposition_bytes_pc_plus_35 - new_term.bc_decomposition_sel_pc_plus_35 * new_term.bc_decomposition_bytes_pc_plus_34_shift); tmp *= scaling_factor; - std::get<38>(evals) += typename Accumulator::View(tmp); + std::get<82>(evals) += typename Accumulator::View(tmp); } } }; @@ -351,16 +637,37 @@ template class bc_decomposition : public Relation SRC_COLUMNS = { Column::bc_decomposition_abs_diff }; + static constexpr std::array DST_COLUMNS = { Column::precomputed_clk }; + + template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) + { + return (in._bc_decomposition_sel() == 1 || in._precomputed_sel_range_16() == 1); + } + + template + static inline auto compute_inverse_exists(const AllEntities& in) + { + using View = typename Accumulator::View; + const auto is_operation = View(in._bc_decomposition_sel()); + const auto is_table_entry = View(in._precomputed_sel_range_16()); + return (is_operation + is_table_entry - is_operation * is_table_entry); + } + + template static inline auto get_const_entities(const AllEntities& in) + { + return get_entities(in); + } + + template static inline auto get_nonconst_entities(AllEntities& in) + { + return get_entities(in); + } + + template static inline auto get_entities(AllEntities&& in) + { + return std::forward_as_tuple(in._lookup_bytecode_remaining_abs_diff_u16_inv(), + in._lookup_bytecode_remaining_abs_diff_u16_counts(), + in._bc_decomposition_sel(), + in._precomputed_sel_range_16(), + in._bc_decomposition_abs_diff(), + in._precomputed_clk()); + } +}; + +template +class lookup_bytecode_remaining_abs_diff_u16_relation + : public GenericLookupRelation { + public: + using Settings = lookup_bytecode_remaining_abs_diff_u16_lookup_settings; + static constexpr std::string_view NAME = lookup_bytecode_remaining_abs_diff_u16_lookup_settings::NAME; + + template inline static bool skip(const AllEntities& in) + { + return in.bc_decomposition_sel.is_zero() && in.precomputed_sel_range_16.is_zero(); + } + + static std::string get_subrelation_label(size_t index) + { + if (index == 0) { + return "INVERSES_ARE_CORRECT"; + } else if (index == 1) { + return "ACCUMULATION_IS_CORRECT"; + } + return std::to_string(index); + } +}; + /////////////////// lookup_bytecode_to_read_unary /////////////////// class lookup_bytecode_to_read_unary_lookup_settings { diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp index c9e37cca75ab..c93ac07f8300 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp @@ -1,5 +1,6 @@ #include "barretenberg/vm2/tracegen/bytecode_trace.hpp" +#include #include #include #include @@ -11,8 +12,6 @@ namespace bb::avm2::tracegen { namespace { -constexpr uint32_t DECOMPOSE_WINDOW_SIZE = 36; - // This returns a number whose first n bits are set to 1. uint64_t as_unary(uint32_t n) { @@ -31,18 +30,20 @@ void BytecodeTraceBuilder::process_decomposition( // We start from row 1 because we need a row of zeroes for the shifts. uint32_t row = 1; - uint8_t id = 0; for (const auto& event : events) { const auto& bytecode = *event.bytecode; + const auto id = event.bytecode_id; auto bytecode_at = [&bytecode](size_t i) -> uint8_t { return i < bytecode.size() ? bytecode[i] : 0; }; auto bytecode_exists_at = [&bytecode](size_t i) -> uint8_t { return i < bytecode.size() ? 1 : 0; }; const uint32_t bytecode_len = static_cast(bytecode.size()); - for (uint32_t i = 0; i < bytecode.size(); i++) { + for (uint32_t i = 0; i < bytecode_len; i++) { const uint32_t remaining = bytecode_len - i; const uint32_t bytes_to_read = std::min(remaining, DECOMPOSE_WINDOW_SIZE); - bool is_last = remaining == 1; + const uint32_t abs_diff = DECOMPOSE_WINDOW_SIZE > remaining ? DECOMPOSE_WINDOW_SIZE - remaining + : remaining - DECOMPOSE_WINDOW_SIZE; + const bool is_last = remaining == 1; trace.set( row, @@ -52,6 +53,9 @@ void BytecodeTraceBuilder::process_decomposition( { C::bc_decomposition_pc, i }, { C::bc_decomposition_last_of_contract, is_last ? 1 : 0 }, { C::bc_decomposition_bytes_remaining, remaining }, + { C::bc_decomposition_bytes_rem_inv, FF(remaining).invert() }, // remaining != 0 for activated rows + { C::bc_decomposition_bytes_rem_min_one_inv, is_last ? 0 : FF(remaining - 1).invert() }, + { C::bc_decomposition_abs_diff, abs_diff }, { C::bc_decomposition_bytes_to_read, bytes_to_read }, { C::bc_decomposition_bytes_to_read_unary, as_unary(bytes_to_read) }, { C::bc_decomposition_sel_overflow_correction_needed, remaining < DECOMPOSE_WINDOW_SIZE ? 1 : 0 }, @@ -131,7 +135,6 @@ void BytecodeTraceBuilder::process_decomposition( } }); row++; } - id++; } } diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.hpp index 618219fca0f1..32c896eff567 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.hpp @@ -7,6 +7,8 @@ namespace bb::avm2::tracegen { +constexpr uint32_t DECOMPOSE_WINDOW_SIZE = 36; + class BytecodeTraceBuilder final { public: void process_hashing(const simulation::EventEmitterInterface::Container& events, diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.test.cpp new file mode 100644 index 000000000000..66572f533647 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.test.cpp @@ -0,0 +1,251 @@ +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "barretenberg/vm2/generated/flavor_settings.hpp" +#include "barretenberg/vm2/generated/full_row.hpp" +#include "barretenberg/vm2/testing/macros.hpp" +#include "barretenberg/vm2/tracegen/bytecode_trace.hpp" +#include "barretenberg/vm2/tracegen/test_trace_container.hpp" + +namespace bb::avm2::tracegen { +namespace { + +using testing::Field; + +using R = TestTraceContainer::Row; +using FF = R::FF; + +TEST(AvmTraceGenBytecodeTest, basicShortLength) +{ + TestTraceContainer trace; + BytecodeTraceBuilder builder; + + builder.process_decomposition( + { + simulation::BytecodeDecompositionEvent{ + .bytecode_id = 43, + .bytecode = std::make_shared>(std::vector{ 12, 31, 5, 2 }), + }, + }, + trace); + + // One extra empty row is prepended. Note that precomputed_first_row is not set through process_decomposition() + // because it pertains to another subtrace. + EXPECT_EQ(trace.as_rows().size(), 4 + 1); + + // We do not inspect row at index 0 as it is completely empty. + EXPECT_THAT(trace.as_rows()[1], + AllOf(ROW_FIELD_EQ(R, bc_decomposition_sel, 1), + ROW_FIELD_EQ(R, bc_decomposition_id, 43), + ROW_FIELD_EQ(R, bc_decomposition_bytes, 12), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_1, 31), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_2, 5), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_3, 2), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_4, 0), + ROW_FIELD_EQ(R, bc_decomposition_pc, 0), + ROW_FIELD_EQ(R, bc_decomposition_bytes_remaining, 4), + ROW_FIELD_EQ(R, bc_decomposition_sel_overflow_correction_needed, 1), + ROW_FIELD_EQ(R, bc_decomposition_abs_diff, DECOMPOSE_WINDOW_SIZE - 4), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read, 4), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read_unary, (1 << 4) - 1), + ROW_FIELD_EQ(R, bc_decomposition_last_of_contract, 0))); + + EXPECT_THAT(trace.as_rows()[2], + AllOf(ROW_FIELD_EQ(R, bc_decomposition_sel, 1), + ROW_FIELD_EQ(R, bc_decomposition_id, 43), + ROW_FIELD_EQ(R, bc_decomposition_bytes, 31), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_1, 5), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_2, 2), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_3, 0), + ROW_FIELD_EQ(R, bc_decomposition_pc, 1), + ROW_FIELD_EQ(R, bc_decomposition_bytes_remaining, 3), + ROW_FIELD_EQ(R, bc_decomposition_sel_overflow_correction_needed, 1), + ROW_FIELD_EQ(R, bc_decomposition_abs_diff, DECOMPOSE_WINDOW_SIZE - 3), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read, 3), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read_unary, (1 << 3) - 1), + ROW_FIELD_EQ(R, bc_decomposition_last_of_contract, 0))); + + EXPECT_THAT(trace.as_rows()[3], + AllOf(ROW_FIELD_EQ(R, bc_decomposition_sel, 1), + ROW_FIELD_EQ(R, bc_decomposition_id, 43), + ROW_FIELD_EQ(R, bc_decomposition_bytes, 5), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_1, 2), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_2, 0), + ROW_FIELD_EQ(R, bc_decomposition_pc, 2), + ROW_FIELD_EQ(R, bc_decomposition_bytes_remaining, 2), + ROW_FIELD_EQ(R, bc_decomposition_sel_overflow_correction_needed, 1), + ROW_FIELD_EQ(R, bc_decomposition_abs_diff, DECOMPOSE_WINDOW_SIZE - 2), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read, 2), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read_unary, (1 << 2) - 1), + ROW_FIELD_EQ(R, bc_decomposition_last_of_contract, 0))); + + EXPECT_THAT(trace.as_rows()[4], + AllOf(ROW_FIELD_EQ(R, bc_decomposition_sel, 1), + ROW_FIELD_EQ(R, bc_decomposition_id, 43), + ROW_FIELD_EQ(R, bc_decomposition_bytes, 2), + ROW_FIELD_EQ(R, bc_decomposition_bytes_pc_plus_1, 0), + ROW_FIELD_EQ(R, bc_decomposition_pc, 3), + ROW_FIELD_EQ(R, bc_decomposition_bytes_remaining, 1), + ROW_FIELD_EQ(R, bc_decomposition_sel_overflow_correction_needed, 1), + ROW_FIELD_EQ(R, bc_decomposition_abs_diff, DECOMPOSE_WINDOW_SIZE - 1), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read, 1), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read_unary, 1), + ROW_FIELD_EQ(R, bc_decomposition_last_of_contract, 1))); +} + +TEST(AvmTraceGenBytecodeTest, basicLongerThanWindowSize) +{ + TestTraceContainer trace; + BytecodeTraceBuilder builder; + + constexpr auto bytecode_size = DECOMPOSE_WINDOW_SIZE + 8; + std::vector bytecode(bytecode_size); + const uint8_t first_byte = 17; // Arbitrary start value and we increment by one. We will hit invalid opcodes + // but it should not matter. + + for (uint8_t i = 0; i < bytecode_size; i++) { + bytecode[i] = i + first_byte; + } + + builder.process_decomposition( + { + simulation::BytecodeDecompositionEvent{ + .bytecode_id = 7, + .bytecode = std::make_shared>(bytecode), + }, + }, + trace); + + // One extra empty row is prepended. Note that precomputed_first_row is not set through process_decomposition() + // because it pertains to another subtrace. + EXPECT_EQ(trace.as_rows().size(), bytecode_size + 1); + + // We do not inspect row at index 0 as it is completely empty. + EXPECT_THAT(trace.as_rows()[1], + AllOf(ROW_FIELD_EQ(R, bc_decomposition_sel, 1), + ROW_FIELD_EQ(R, bc_decomposition_id, 7), + ROW_FIELD_EQ(R, bc_decomposition_bytes, first_byte), + ROW_FIELD_EQ(R, bc_decomposition_pc, 0), + ROW_FIELD_EQ(R, bc_decomposition_bytes_remaining, bytecode_size), + ROW_FIELD_EQ(R, bc_decomposition_sel_overflow_correction_needed, 0), + ROW_FIELD_EQ(R, bc_decomposition_abs_diff, 8), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read, DECOMPOSE_WINDOW_SIZE), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read_unary, (uint64_t(1) << DECOMPOSE_WINDOW_SIZE) - 1), + ROW_FIELD_EQ(R, bc_decomposition_last_of_contract, 0))); + + // We are interested to inspect the boundary aroud bytes_remaining == windows size + + EXPECT_THAT(trace.as_rows()[9], + AllOf(ROW_FIELD_EQ(R, bc_decomposition_sel, 1), + ROW_FIELD_EQ(R, bc_decomposition_id, 7), + ROW_FIELD_EQ(R, bc_decomposition_bytes, first_byte + 8), + ROW_FIELD_EQ(R, bc_decomposition_pc, 8), + ROW_FIELD_EQ(R, bc_decomposition_bytes_remaining, DECOMPOSE_WINDOW_SIZE), + ROW_FIELD_EQ(R, bc_decomposition_sel_overflow_correction_needed, 0), + ROW_FIELD_EQ(R, bc_decomposition_abs_diff, 0), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read, DECOMPOSE_WINDOW_SIZE), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read_unary, (uint64_t(1) << DECOMPOSE_WINDOW_SIZE) - 1), + ROW_FIELD_EQ(R, bc_decomposition_last_of_contract, 0))); + + EXPECT_THAT( + trace.as_rows()[10], + AllOf(ROW_FIELD_EQ(R, bc_decomposition_sel, 1), + ROW_FIELD_EQ(R, bc_decomposition_id, 7), + ROW_FIELD_EQ(R, bc_decomposition_bytes, first_byte + 9), + ROW_FIELD_EQ(R, bc_decomposition_pc, 9), + ROW_FIELD_EQ(R, bc_decomposition_bytes_remaining, DECOMPOSE_WINDOW_SIZE - 1), + ROW_FIELD_EQ(R, bc_decomposition_sel_overflow_correction_needed, 1), + ROW_FIELD_EQ(R, bc_decomposition_abs_diff, 1), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read, DECOMPOSE_WINDOW_SIZE - 1), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read_unary, (uint64_t(1) << (DECOMPOSE_WINDOW_SIZE - 1)) - 1), + ROW_FIELD_EQ(R, bc_decomposition_last_of_contract, 0))); + + // Last row + EXPECT_THAT(trace.as_rows()[bytecode_size], + AllOf(ROW_FIELD_EQ(R, bc_decomposition_sel, 1), + ROW_FIELD_EQ(R, bc_decomposition_id, 7), + ROW_FIELD_EQ(R, bc_decomposition_bytes, first_byte + bytecode_size - 1), + ROW_FIELD_EQ(R, bc_decomposition_pc, bytecode_size - 1), + ROW_FIELD_EQ(R, bc_decomposition_bytes_remaining, 1), + ROW_FIELD_EQ(R, bc_decomposition_sel_overflow_correction_needed, 1), + ROW_FIELD_EQ(R, bc_decomposition_abs_diff, DECOMPOSE_WINDOW_SIZE - 1), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read, 1), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read_unary, 1), + ROW_FIELD_EQ(R, bc_decomposition_last_of_contract, 1))); +} + +TEST(AvmTraceGenBytecodeTest, multipleEvents) +{ + TestTraceContainer trace; + BytecodeTraceBuilder builder; + + std::vector bc_sizes = { DECOMPOSE_WINDOW_SIZE + 2, 17, DECOMPOSE_WINDOW_SIZE, 1 }; + std::vector> bytecodes(4); + + std::transform(bc_sizes.begin(), bc_sizes.end(), bytecodes.begin(), [](uint32_t bc_size) -> std::vector { + std::vector bytecode(bc_size); + for (uint8_t i = 0; i < bc_size; i++) { + bytecode[i] = i * i; // Arbitrary bytecode that we will not inspect below + } + + return bytecode; + }); + + builder.process_decomposition( + { + simulation::BytecodeDecompositionEvent{ + .bytecode_id = 0, + .bytecode = std::make_shared>(bytecodes[0]), + }, + simulation::BytecodeDecompositionEvent{ + .bytecode_id = 1, + .bytecode = std::make_shared>(bytecodes[1]), + }, + simulation::BytecodeDecompositionEvent{ + .bytecode_id = 2, + .bytecode = std::make_shared>(bytecodes[2]), + }, + simulation::BytecodeDecompositionEvent{ + .bytecode_id = 3, + .bytecode = std::make_shared>(bytecodes[3]), + }, + }, + trace); + + // One extra empty row is prepended. + EXPECT_EQ(trace.as_rows().size(), 2 * DECOMPOSE_WINDOW_SIZE + 20 + 1); + + const auto rows = trace.as_rows(); + size_t row_pos = 1; + for (uint32_t i = 0; i < 4; i++) { + for (uint32_t j = 0; j < bc_sizes[i]; j++) { + const auto bytes_rem = bc_sizes[i] - j; + EXPECT_THAT( + rows.at(row_pos), + AllOf(ROW_FIELD_EQ(R, bc_decomposition_sel, 1), + ROW_FIELD_EQ(R, bc_decomposition_id, i), + ROW_FIELD_EQ(R, bc_decomposition_pc, j), + ROW_FIELD_EQ(R, bc_decomposition_bytes_remaining, bytes_rem), + ROW_FIELD_EQ(R, + bc_decomposition_sel_overflow_correction_needed, + bytes_rem < DECOMPOSE_WINDOW_SIZE ? 1 : 0), + ROW_FIELD_EQ(R, + bc_decomposition_abs_diff, + bytes_rem < DECOMPOSE_WINDOW_SIZE ? DECOMPOSE_WINDOW_SIZE - bytes_rem + : bytes_rem - DECOMPOSE_WINDOW_SIZE), + ROW_FIELD_EQ(R, bc_decomposition_bytes_to_read, std::min(DECOMPOSE_WINDOW_SIZE, bytes_rem)), + ROW_FIELD_EQ(R, bc_decomposition_last_of_contract, j == bc_sizes[i] - 1 ? 1 : 0))); + row_pos++; + } + } +} + +} // namespace +} // namespace bb::avm2::tracegen \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp index 8ab5739a2304..0402379b4729 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp @@ -221,8 +221,9 @@ TraceContainer AvmTraceGenHelper::generate_trace(EventsContainer&& events) std::make_unique>(), std::make_unique>(), std::make_unique>(), - std::make_unique>(), - std::make_unique>()); + std::make_unique>(), + std::make_unique>(), + std::make_unique>()); AVM_TRACK_TIME("tracegen/interactions", parallel_for(jobs_interactions.size(), [&](size_t i) { jobs_interactions[i]->process(trace); })); }