From 7eef61b3139dce303d05ddd93a6b4fef21f2b65c Mon Sep 17 00:00:00 2001 From: jeanmon Date: Tue, 26 Mar 2024 16:27:38 +0000 Subject: [PATCH] Introduce selectors to enable range checks of 8-bit and 16-bit sizes --- barretenberg/cpp/pil/avm/avm_main.pil | 5 + .../relations/generated/avm/avm_alu.hpp | 84 ++++++------ .../relations/generated/avm/avm_binary.hpp | 32 ++--- .../relations/generated/avm/avm_main.hpp | 106 +++++++-------- .../relations/generated/avm/avm_mem.hpp | 48 +++---- .../relations/generated/avm/declare_views.hpp | 28 ++-- .../barretenberg/vm/avm_trace/avm_trace.cpp | 32 +++-- .../barretenberg/vm/avm_trace/avm_trace.hpp | 2 + .../vm/generated/avm_circuit_builder.hpp | 68 +++++----- .../barretenberg/vm/generated/avm_flavor.hpp | 127 +++++++++++------- .../vm/generated/avm_verifier.cpp | 4 + 11 files changed, 297 insertions(+), 239 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_main.pil b/barretenberg/cpp/pil/avm/avm_main.pil index 53cb8d86ccd8..a6ef15fcad1a 100644 --- a/barretenberg/cpp/pil/avm/avm_main.pil +++ b/barretenberg/cpp/pil/avm/avm_main.pil @@ -10,6 +10,11 @@ namespace avm_main(256); pol constant first = [1] + [0]*; // Used mostly to toggle off the first row consisting // only in first element of shifted polynomials. + //===== Fix Range Checks Selectors============================================= + // We re-use the clk column for the lookup values of 8-bit resp. 16-bit range check. + pol commit sel_rng_8; // Boolean selector for the 8-bit range check lookup + pol commit sel_rng_16; // Boolean selector for the 16-bit range check lookup + //===== CONTROL FLOW ========================================================== // Program counter pol commit pc; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp index 8fe200d9ff9e..f9e5e00873ea 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp @@ -7,77 +7,77 @@ namespace bb::Avm_vm { template struct Avm_aluRow { - FF avm_alu_alu_in_tag{}; + FF avm_alu_alu_ff_tag{}; + FF avm_alu_alu_u16_r1_shift{}; + FF avm_alu_alu_u16_r3_shift{}; + FF avm_alu_alu_u16_r4{}; + FF avm_alu_alu_u8_r1{}; + FF avm_alu_alu_u16_r7{}; FF avm_alu_alu_u16_r2_shift{}; + FF avm_alu_alu_op_eq{}; FF avm_alu_alu_u8_tag{}; + FF avm_alu_alu_u16_r5_shift{}; + FF avm_alu_alu_u16_tag{}; + FF avm_alu_alu_u16_r4_shift{}; + FF avm_alu_alu_u16_r6_shift{}; + FF avm_alu_alu_u64_r0{}; FF avm_alu_alu_u16_r0_shift{}; - FF avm_alu_alu_u16_r3_shift{}; - FF avm_alu_alu_u16_r0{}; - FF avm_alu_alu_cf{}; - FF avm_alu_alu_op_mul{}; + FF avm_alu_alu_op_add{}; + FF avm_alu_alu_ic{}; FF avm_alu_alu_u32_tag{}; + FF avm_alu_alu_op_sub{}; + FF avm_alu_alu_u16_r6{}; FF avm_alu_alu_u64_tag{}; - FF avm_alu_alu_u16_r1{}; - FF avm_alu_alu_u16_r1_shift{}; - FF avm_alu_alu_u16_r4_shift{}; - FF avm_alu_alu_u64_r0{}; - FF avm_alu_alu_u16_r7{}; + FF avm_alu_alu_u8_r0{}; FF avm_alu_alu_ib{}; + FF avm_alu_alu_u16_r1{}; + FF avm_alu_alu_u16_r3{}; + FF avm_alu_alu_u16_r0{}; + FF avm_alu_alu_cf{}; FF avm_alu_alu_u16_r7_shift{}; - FF avm_alu_alu_ia{}; - FF avm_alu_alu_op_sub{}; - FF avm_alu_alu_u8_r0{}; - FF avm_alu_alu_op_not{}; - FF avm_alu_alu_ff_tag{}; + FF avm_alu_alu_u16_r5{}; FF avm_alu_alu_u16_r2{}; - FF avm_alu_alu_u16_r4{}; - FF avm_alu_alu_u8_r1{}; - FF avm_alu_alu_u16_r6_shift{}; - FF avm_alu_alu_op_eq{}; - FF avm_alu_alu_op_add{}; FF avm_alu_alu_op_eq_diff_inv{}; - FF avm_alu_alu_u16_r5_shift{}; - FF avm_alu_alu_u16_tag{}; FF avm_alu_alu_u128_tag{}; - FF avm_alu_alu_u16_r6{}; - FF avm_alu_alu_u16_r3{}; - FF avm_alu_alu_u16_r5{}; - FF avm_alu_alu_ic{}; FF avm_alu_alu_sel{}; + FF avm_alu_alu_op_not{}; + FF avm_alu_alu_op_mul{}; + FF avm_alu_alu_in_tag{}; + FF avm_alu_alu_ia{}; }; inline std::string get_relation_label_avm_alu(int index) { switch (index) { - case 13: - return "ALU_MUL_COMMON_2"; - - case 20: - return "ALU_OP_EQ"; - - case 11: - return "ALU_MULTIPLICATION_FF"; + case 9: + return "ALU_ADD_SUB_1"; case 19: return "ALU_RES_IS_BOOL"; - case 9: - return "ALU_ADD_SUB_1"; - case 16: return "ALU_MULTIPLICATION_OUT_U128"; - case 12: - return "ALU_MUL_COMMON_1"; - case 10: return "ALU_ADD_SUB_2"; - case 17: - return "ALU_FF_NOT_XOR"; + case 12: + return "ALU_MUL_COMMON_1"; case 18: return "ALU_OP_NOT"; + + case 11: + return "ALU_MULTIPLICATION_FF"; + + case 13: + return "ALU_MUL_COMMON_2"; + + case 20: + return "ALU_OP_EQ"; + + case 17: + return "ALU_FF_NOT_XOR"; } return std::to_string(index); } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_binary.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_binary.hpp index ee9948c94f12..ab696f4c5607 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_binary.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_binary.hpp @@ -7,41 +7,41 @@ namespace bb::Avm_vm { template struct Avm_binaryRow { - FF avm_binary_mem_tag_ctr_inv{}; - FF avm_binary_bin_ic_bytes{}; - FF avm_binary_acc_ia{}; - FF avm_binary_acc_ib{}; - FF avm_binary_acc_ic{}; - FF avm_binary_mem_tag_ctr_shift{}; - FF avm_binary_acc_ia_shift{}; + FF avm_binary_acc_ic_shift{}; FF avm_binary_op_id_shift{}; + FF avm_binary_acc_ib_shift{}; FF avm_binary_bin_sel{}; + FF avm_binary_mem_tag_ctr_shift{}; + FF avm_binary_mem_tag_ctr_inv{}; + FF avm_binary_mem_tag_ctr{}; + FF avm_binary_acc_ib{}; FF avm_binary_bin_ib_bytes{}; + FF avm_binary_acc_ia{}; + FF avm_binary_bin_ic_bytes{}; FF avm_binary_op_id{}; FF avm_binary_bin_ia_bytes{}; - FF avm_binary_acc_ib_shift{}; - FF avm_binary_mem_tag_ctr{}; - FF avm_binary_acc_ic_shift{}; + FF avm_binary_acc_ia_shift{}; + FF avm_binary_acc_ic{}; }; inline std::string get_relation_label_avm_binary(int index) { switch (index) { + case 8: + return "ACC_REL_B"; + case 9: return "ACC_REL_C"; + case 2: + return "MEM_TAG_REL"; + case 7: return "ACC_REL_A"; case 1: return "OP_ID_REL"; - case 2: - return "MEM_TAG_REL"; - - case 8: - return "ACC_REL_B"; - case 3: return "BIN_SEL_CTR_REL"; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp index 66d50ffe2202..95322178c101 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp @@ -7,90 +7,90 @@ namespace bb::Avm_vm { template struct Avm_mainRow { - FF avm_main_w_in_tag{}; - FF avm_main_sel_op_add{}; - FF avm_main_bin_sel{}; - FF avm_main_ind_op_a{}; + FF avm_main_sel_internal_call{}; + FF avm_main_mem_op_c{}; + FF avm_main_internal_return_ptr_shift{}; + FF avm_main_mem_idx_a{}; FF avm_main_r_in_tag{}; + FF avm_main_mem_op_a{}; + FF avm_main_sel_op_add{}; + FF avm_main_rwc{}; + FF avm_main_ind_op_c{}; FF avm_main_sel_op_and{}; - FF avm_main_sel_op_mul{}; - FF avm_main_mem_op_b{}; + FF avm_main_mem_idx_b{}; + FF avm_main_alu_sel{}; FF avm_main_sel_op_or{}; - FF avm_main_mem_op_c{}; - FF avm_main_sel_halt{}; - FF avm_main_inv{}; - FF avm_main_pc{}; - FF avm_main_sel_op_not{}; - FF avm_main_rwa{}; + FF avm_main_ia{}; FF avm_main_first{}; + FF avm_main_ib{}; + FF avm_main_sel_internal_return{}; + FF avm_main_ind_op_b{}; + FF avm_main_inv{}; FF avm_main_sel_op_div{}; + FF avm_main_sel_op_not{}; + FF avm_main_mem_op_b{}; + FF avm_main_ind_op_a{}; + FF avm_main_rwb{}; + FF avm_main_pc_shift{}; + FF avm_main_op_err{}; + FF avm_main_sel_op_mul{}; + FF avm_main_sel_op_xor{}; + FF avm_main_sel_op_sub{}; FF avm_main_internal_return_ptr{}; - FF avm_main_sel_op_eq{}; - FF avm_main_ind_op_c{}; - FF avm_main_ia{}; + FF avm_main_rwa{}; FF avm_main_bin_op_id{}; FF avm_main_sel_jump{}; - FF avm_main_sel_internal_call{}; - FF avm_main_op_err{}; - FF avm_main_rwb{}; - FF avm_main_sel_internal_return{}; - FF avm_main_tag_err{}; - FF avm_main_mem_idx_b{}; + FF avm_main_sel_op_eq{}; + FF avm_main_pc{}; + FF avm_main_w_in_tag{}; + FF avm_main_sel_halt{}; FF avm_main_sel_mov{}; FF avm_main_ic{}; - FF avm_main_rwc{}; - FF avm_main_pc_shift{}; - FF avm_main_ind_op_b{}; - FF avm_main_ib{}; - FF avm_main_sel_op_sub{}; - FF avm_main_mem_idx_a{}; - FF avm_main_mem_op_a{}; - FF avm_main_alu_sel{}; - FF avm_main_internal_return_ptr_shift{}; - FF avm_main_sel_op_xor{}; + FF avm_main_tag_err{}; + FF avm_main_bin_sel{}; }; inline std::string get_relation_label_avm_main(int index) { switch (index) { - case 28: - return "SUBOP_DIVISION_ZERO_ERR2"; - - case 43: - return "INTERNAL_RETURN_POINTER_CONSISTENCY"; - - case 45: - return "MOV_MAIN_SAME_TAG"; - - case 44: - return "MOV_SAME_VALUE"; - case 27: return "SUBOP_DIVISION_ZERO_ERR1"; case 31: return "RETURN_POINTER_INCREMENT"; - case 42: - return "PC_INCREMENT"; + case 29: + return "SUBOP_ERROR_RELEVANT_OP"; - case 37: - return "RETURN_POINTER_DECREMENT"; + case 43: + return "INTERNAL_RETURN_POINTER_CONSISTENCY"; case 25: return "EQ_OUTPUT_U8"; - case 47: - return "BIN_SEL_1"; + case 37: + return "RETURN_POINTER_DECREMENT"; - case 48: - return "BIN_SEL_2"; + case 44: + return "MOV_SAME_VALUE"; case 26: return "SUBOP_DIVISION_FF"; - case 29: - return "SUBOP_ERROR_RELEVANT_OP"; + case 28: + return "SUBOP_DIVISION_ZERO_ERR2"; + + case 45: + return "MOV_MAIN_SAME_TAG"; + + case 47: + return "BIN_SEL_1"; + + case 42: + return "PC_INCREMENT"; + + case 48: + return "BIN_SEL_2"; } return std::to_string(index); } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_mem.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_mem.hpp index 6ea3004b2dfb..42ad067c6c34 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_mem.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_mem.hpp @@ -7,56 +7,56 @@ namespace bb::Avm_vm { template struct Avm_memRow { - FF avm_mem_m_op_b{}; - FF avm_mem_m_lastAccess{}; + FF avm_mem_m_tag_shift{}; FF avm_mem_m_rw_shift{}; - FF avm_mem_m_ind_op_a{}; - FF avm_mem_m_ind_op_b{}; - FF avm_mem_m_sub_clk{}; FF avm_mem_r_in_tag{}; - FF avm_mem_m_tag_shift{}; - FF avm_mem_m_addr{}; - FF avm_mem_m_rw{}; - FF avm_mem_m_op_a{}; - FF avm_mem_m_tag{}; - FF avm_mem_m_val_shift{}; FF avm_mem_m_val{}; - FF avm_mem_m_one_min_inv{}; - FF avm_mem_m_op_c{}; - FF avm_mem_w_in_tag{}; FF avm_mem_m_addr_shift{}; + FF avm_mem_m_tag{}; + FF avm_mem_m_val_shift{}; FF avm_mem_m_sel_mov{}; FF avm_mem_m_last{}; + FF avm_mem_m_sub_clk{}; + FF avm_mem_m_op_c{}; + FF avm_mem_m_op_b{}; + FF avm_mem_m_addr{}; FF avm_mem_m_tag_err{}; + FF avm_mem_m_rw{}; + FF avm_mem_m_op_a{}; FF avm_mem_m_ind_op_c{}; + FF avm_mem_m_lastAccess{}; + FF avm_mem_m_ind_op_a{}; + FF avm_mem_m_one_min_inv{}; + FF avm_mem_w_in_tag{}; + FF avm_mem_m_ind_op_b{}; }; inline std::string get_relation_label_avm_mem(int index) { switch (index) { + case 13: + return "MEM_READ_WRITE_VAL_CONSISTENCY"; + case 14: return "MEM_READ_WRITE_TAG_CONSISTENCY"; - case 12: - return "MEM_LAST_ACCESS_DELIMITER"; - case 19: return "NO_TAG_ERR_WRITE"; - case 13: - return "MEM_READ_WRITE_VAL_CONSISTENCY"; + case 26: + return "MOV_SAME_TAG"; + + case 12: + return "MEM_LAST_ACCESS_DELIMITER"; case 15: return "MEM_ZERO_INIT"; - case 26: - return "MOV_SAME_TAG"; + case 16: + return "MEM_IN_TAG_CONSISTENCY_1"; case 17: return "MEM_IN_TAG_CONSISTENCY_2"; - - case 16: - return "MEM_IN_TAG_CONSISTENCY_1"; } return std::to_string(index); } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp index 8220b92dcb78..6148feef5cc4 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -74,6 +74,8 @@ [[maybe_unused]] auto avm_binary_start = View(new_term.avm_binary_start); \ [[maybe_unused]] auto avm_binary_mem_tag_ctr = View(new_term.avm_binary_mem_tag_ctr); \ [[maybe_unused]] auto avm_binary_mem_tag_ctr_inv = View(new_term.avm_binary_mem_tag_ctr_inv); \ + [[maybe_unused]] auto avm_main_sel_rng_8 = View(new_term.avm_main_sel_rng_8); \ + [[maybe_unused]] auto avm_main_sel_rng_16 = View(new_term.avm_main_sel_rng_16); \ [[maybe_unused]] auto avm_main_pc = View(new_term.avm_main_pc); \ [[maybe_unused]] auto avm_main_internal_return_ptr = View(new_term.avm_main_internal_return_ptr); \ [[maybe_unused]] auto avm_main_sel_internal_call = View(new_term.avm_main_sel_internal_call); \ @@ -133,22 +135,22 @@ [[maybe_unused]] auto lookup_byte_operations_counts = View(new_term.lookup_byte_operations_counts); \ [[maybe_unused]] auto incl_main_tag_err_counts = View(new_term.incl_main_tag_err_counts); \ [[maybe_unused]] auto incl_mem_tag_err_counts = View(new_term.incl_mem_tag_err_counts); \ - [[maybe_unused]] auto avm_mem_m_rw_shift = View(new_term.avm_mem_m_rw_shift); \ [[maybe_unused]] auto avm_mem_m_tag_shift = View(new_term.avm_mem_m_tag_shift); \ - [[maybe_unused]] auto avm_mem_m_val_shift = View(new_term.avm_mem_m_val_shift); \ + [[maybe_unused]] auto avm_mem_m_rw_shift = View(new_term.avm_mem_m_rw_shift); \ [[maybe_unused]] auto avm_mem_m_addr_shift = View(new_term.avm_mem_m_addr_shift); \ - [[maybe_unused]] auto avm_main_pc_shift = View(new_term.avm_main_pc_shift); \ + [[maybe_unused]] auto avm_mem_m_val_shift = View(new_term.avm_mem_m_val_shift); \ + [[maybe_unused]] auto avm_binary_acc_ic_shift = View(new_term.avm_binary_acc_ic_shift); \ + [[maybe_unused]] auto avm_binary_op_id_shift = View(new_term.avm_binary_op_id_shift); \ + [[maybe_unused]] auto avm_binary_acc_ib_shift = View(new_term.avm_binary_acc_ib_shift); \ + [[maybe_unused]] auto avm_binary_mem_tag_ctr_shift = View(new_term.avm_binary_mem_tag_ctr_shift); \ + [[maybe_unused]] auto avm_binary_acc_ia_shift = View(new_term.avm_binary_acc_ia_shift); \ [[maybe_unused]] auto avm_main_internal_return_ptr_shift = View(new_term.avm_main_internal_return_ptr_shift); \ - [[maybe_unused]] auto avm_alu_alu_u16_r2_shift = View(new_term.avm_alu_alu_u16_r2_shift); \ - [[maybe_unused]] auto avm_alu_alu_u16_r0_shift = View(new_term.avm_alu_alu_u16_r0_shift); \ - [[maybe_unused]] auto avm_alu_alu_u16_r3_shift = View(new_term.avm_alu_alu_u16_r3_shift); \ + [[maybe_unused]] auto avm_main_pc_shift = View(new_term.avm_main_pc_shift); \ [[maybe_unused]] auto avm_alu_alu_u16_r1_shift = View(new_term.avm_alu_alu_u16_r1_shift); \ + [[maybe_unused]] auto avm_alu_alu_u16_r3_shift = View(new_term.avm_alu_alu_u16_r3_shift); \ + [[maybe_unused]] auto avm_alu_alu_u16_r2_shift = View(new_term.avm_alu_alu_u16_r2_shift); \ + [[maybe_unused]] auto avm_alu_alu_u16_r5_shift = View(new_term.avm_alu_alu_u16_r5_shift); \ [[maybe_unused]] auto avm_alu_alu_u16_r4_shift = View(new_term.avm_alu_alu_u16_r4_shift); \ - [[maybe_unused]] auto avm_alu_alu_u16_r7_shift = View(new_term.avm_alu_alu_u16_r7_shift); \ [[maybe_unused]] auto avm_alu_alu_u16_r6_shift = View(new_term.avm_alu_alu_u16_r6_shift); \ - [[maybe_unused]] auto avm_alu_alu_u16_r5_shift = View(new_term.avm_alu_alu_u16_r5_shift); \ - [[maybe_unused]] auto avm_binary_mem_tag_ctr_shift = View(new_term.avm_binary_mem_tag_ctr_shift); \ - [[maybe_unused]] auto avm_binary_acc_ia_shift = View(new_term.avm_binary_acc_ia_shift); \ - [[maybe_unused]] auto avm_binary_op_id_shift = View(new_term.avm_binary_op_id_shift); \ - [[maybe_unused]] auto avm_binary_acc_ib_shift = View(new_term.avm_binary_acc_ib_shift); \ - [[maybe_unused]] auto avm_binary_acc_ic_shift = View(new_term.avm_binary_acc_ic_shift); + [[maybe_unused]] auto avm_alu_alu_u16_r0_shift = View(new_term.avm_alu_alu_u16_r0_shift); \ + [[maybe_unused]] auto avm_alu_alu_u16_r7_shift = View(new_term.avm_alu_alu_u16_r7_shift); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp index 49e6ac468f8f..0bbb9748f0af 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -1120,18 +1120,14 @@ std::vector AvmTraceBuilder::finalize() // Get tag_err counts from the mem_trace_builder finalise_mem_trace_lookup_counts(); - // TODO: We will have to handle this through error handling and not an assertion - // Smaller than N because we have to add an extra initial row to support shifted - // elements - assert(mem_trace_size < AVM_TRACE_SIZE); - assert(main_trace_size < AVM_TRACE_SIZE); - assert(alu_trace_size < AVM_TRACE_SIZE); - // Main Trace needs to be at least as big as the biggest subtrace. // If the bin_trace_size has entries, we need the main_trace to be as big as our byte lookup table (3 * 2**16 // long) - size_t lookup_table = bin_trace_size > 0 ? 3 * (1 << 16) : 0; - std::vector trace_sizes = { mem_trace_size, main_trace_size, alu_trace_size, lookup_table }; + size_t const lookup_table_size = bin_trace_size > 0 ? 3 * (1 << 16) : 0; + size_t const range_check_size = range_checked_required ? UINT16_MAX : 0; + std::vector trace_sizes = { + mem_trace_size, main_trace_size, alu_trace_size, lookup_table_size, range_check_size + }; auto trace_size = std::max_element(trace_sizes.begin(), trace_sizes.end()); // We only need to pad with zeroes to the size to the largest trace here, pow_2 padding is handled in the @@ -1248,6 +1244,24 @@ std::vector AvmTraceBuilder::finalize() } } + for (size_t i = 0; i < main_trace_size; i++) { + auto& r = main_trace.at(i); + + if ((r.avm_main_sel_op_add == FF(1) || r.avm_main_sel_op_sub == FF(1) || r.avm_main_sel_op_mul == FF(1) || + r.avm_main_sel_op_eq == FF(1) || r.avm_main_sel_op_not == FF(1)) && + r.avm_main_tag_err == FF(0)) { + r.avm_main_alu_sel = FF(1); + } + + if (i <= UINT8_MAX) { + r.avm_main_sel_rng_8 = FF(1); + } + + if (i <= UINT16_MAX) { + r.avm_main_sel_rng_16 = FF(1); + } + } + // Deriving redundant selectors/tags for the main trace. for (Row& r : main_trace) { if ((r.avm_main_sel_op_add == FF(1) || r.avm_main_sel_op_sub == FF(1) || r.avm_main_sel_op_mul == FF(1) || diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp index db65d015d65e..ad865def589a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp @@ -107,6 +107,8 @@ class AvmTraceBuilder { AvmAluTraceBuilder alu_trace_builder; AvmBinaryTraceBuilder bin_trace_builder; + bool range_checked_required = false; + void finalise_mem_trace_lookup_counts(); IndirectThreeResolution resolve_ind_three( diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index f647cf2fc29a..2927780ebf22 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -104,6 +104,8 @@ template struct AvmFullRow { FF avm_binary_start{}; FF avm_binary_mem_tag_ctr{}; FF avm_binary_mem_tag_ctr_inv{}; + FF avm_main_sel_rng_8{}; + FF avm_main_sel_rng_16{}; FF avm_main_pc{}; FF avm_main_internal_return_ptr{}; FF avm_main_sel_internal_call{}; @@ -163,25 +165,25 @@ template struct AvmFullRow { FF lookup_byte_operations_counts{}; FF incl_main_tag_err_counts{}; FF incl_mem_tag_err_counts{}; - FF avm_mem_m_rw_shift{}; FF avm_mem_m_tag_shift{}; - FF avm_mem_m_val_shift{}; + FF avm_mem_m_rw_shift{}; FF avm_mem_m_addr_shift{}; - FF avm_main_pc_shift{}; + FF avm_mem_m_val_shift{}; + FF avm_binary_acc_ic_shift{}; + FF avm_binary_op_id_shift{}; + FF avm_binary_acc_ib_shift{}; + FF avm_binary_mem_tag_ctr_shift{}; + FF avm_binary_acc_ia_shift{}; FF avm_main_internal_return_ptr_shift{}; - FF avm_alu_alu_u16_r2_shift{}; - FF avm_alu_alu_u16_r0_shift{}; - FF avm_alu_alu_u16_r3_shift{}; + FF avm_main_pc_shift{}; FF avm_alu_alu_u16_r1_shift{}; + FF avm_alu_alu_u16_r3_shift{}; + FF avm_alu_alu_u16_r2_shift{}; + FF avm_alu_alu_u16_r5_shift{}; FF avm_alu_alu_u16_r4_shift{}; - FF avm_alu_alu_u16_r7_shift{}; FF avm_alu_alu_u16_r6_shift{}; - FF avm_alu_alu_u16_r5_shift{}; - FF avm_binary_mem_tag_ctr_shift{}; - FF avm_binary_acc_ia_shift{}; - FF avm_binary_op_id_shift{}; - FF avm_binary_acc_ib_shift{}; - FF avm_binary_acc_ic_shift{}; + FF avm_alu_alu_u16_r0_shift{}; + FF avm_alu_alu_u16_r7_shift{}; }; class AvmCircuitBuilder { @@ -194,8 +196,8 @@ class AvmCircuitBuilder { using Polynomial = Flavor::Polynomial; using ProverPolynomials = Flavor::ProverPolynomials; - static constexpr size_t num_fixed_columns = 150; - static constexpr size_t num_polys = 131; + static constexpr size_t num_fixed_columns = 152; + static constexpr size_t num_polys = 133; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -283,6 +285,8 @@ class AvmCircuitBuilder { polys.avm_binary_start[i] = rows[i].avm_binary_start; polys.avm_binary_mem_tag_ctr[i] = rows[i].avm_binary_mem_tag_ctr; polys.avm_binary_mem_tag_ctr_inv[i] = rows[i].avm_binary_mem_tag_ctr_inv; + polys.avm_main_sel_rng_8[i] = rows[i].avm_main_sel_rng_8; + polys.avm_main_sel_rng_16[i] = rows[i].avm_main_sel_rng_16; polys.avm_main_pc[i] = rows[i].avm_main_pc; polys.avm_main_internal_return_ptr[i] = rows[i].avm_main_internal_return_ptr; polys.avm_main_sel_internal_call[i] = rows[i].avm_main_sel_internal_call; @@ -344,25 +348,25 @@ class AvmCircuitBuilder { polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; } - polys.avm_mem_m_rw_shift = Polynomial(polys.avm_mem_m_rw.shifted()); polys.avm_mem_m_tag_shift = Polynomial(polys.avm_mem_m_tag.shifted()); - polys.avm_mem_m_val_shift = Polynomial(polys.avm_mem_m_val.shifted()); + polys.avm_mem_m_rw_shift = Polynomial(polys.avm_mem_m_rw.shifted()); polys.avm_mem_m_addr_shift = Polynomial(polys.avm_mem_m_addr.shifted()); - polys.avm_main_pc_shift = Polynomial(polys.avm_main_pc.shifted()); + polys.avm_mem_m_val_shift = Polynomial(polys.avm_mem_m_val.shifted()); + polys.avm_binary_acc_ic_shift = Polynomial(polys.avm_binary_acc_ic.shifted()); + polys.avm_binary_op_id_shift = Polynomial(polys.avm_binary_op_id.shifted()); + polys.avm_binary_acc_ib_shift = Polynomial(polys.avm_binary_acc_ib.shifted()); + polys.avm_binary_mem_tag_ctr_shift = Polynomial(polys.avm_binary_mem_tag_ctr.shifted()); + polys.avm_binary_acc_ia_shift = Polynomial(polys.avm_binary_acc_ia.shifted()); polys.avm_main_internal_return_ptr_shift = Polynomial(polys.avm_main_internal_return_ptr.shifted()); - polys.avm_alu_alu_u16_r2_shift = Polynomial(polys.avm_alu_alu_u16_r2.shifted()); - polys.avm_alu_alu_u16_r0_shift = Polynomial(polys.avm_alu_alu_u16_r0.shifted()); - polys.avm_alu_alu_u16_r3_shift = Polynomial(polys.avm_alu_alu_u16_r3.shifted()); + polys.avm_main_pc_shift = Polynomial(polys.avm_main_pc.shifted()); polys.avm_alu_alu_u16_r1_shift = Polynomial(polys.avm_alu_alu_u16_r1.shifted()); + polys.avm_alu_alu_u16_r3_shift = Polynomial(polys.avm_alu_alu_u16_r3.shifted()); + polys.avm_alu_alu_u16_r2_shift = Polynomial(polys.avm_alu_alu_u16_r2.shifted()); + polys.avm_alu_alu_u16_r5_shift = Polynomial(polys.avm_alu_alu_u16_r5.shifted()); polys.avm_alu_alu_u16_r4_shift = Polynomial(polys.avm_alu_alu_u16_r4.shifted()); - polys.avm_alu_alu_u16_r7_shift = Polynomial(polys.avm_alu_alu_u16_r7.shifted()); polys.avm_alu_alu_u16_r6_shift = Polynomial(polys.avm_alu_alu_u16_r6.shifted()); - polys.avm_alu_alu_u16_r5_shift = Polynomial(polys.avm_alu_alu_u16_r5.shifted()); - polys.avm_binary_mem_tag_ctr_shift = Polynomial(polys.avm_binary_mem_tag_ctr.shifted()); - polys.avm_binary_acc_ia_shift = Polynomial(polys.avm_binary_acc_ia.shifted()); - polys.avm_binary_op_id_shift = Polynomial(polys.avm_binary_op_id.shifted()); - polys.avm_binary_acc_ib_shift = Polynomial(polys.avm_binary_acc_ib.shifted()); - polys.avm_binary_acc_ic_shift = Polynomial(polys.avm_binary_acc_ic.shifted()); + polys.avm_alu_alu_u16_r0_shift = Polynomial(polys.avm_alu_alu_u16_r0.shifted()); + polys.avm_alu_alu_u16_r7_shift = Polynomial(polys.avm_alu_alu_u16_r7.shifted()); return polys; } @@ -438,6 +442,10 @@ class AvmCircuitBuilder { Avm_vm::get_relation_label_avm_mem)) { return false; } + if (!evaluate_relation.template operator()>("avm_binary", + Avm_vm::get_relation_label_avm_binary)) { + return false; + } if (!evaluate_relation.template operator()>("avm_main", Avm_vm::get_relation_label_avm_main)) { return false; @@ -446,10 +454,6 @@ class AvmCircuitBuilder { Avm_vm::get_relation_label_avm_alu)) { return false; } - if (!evaluate_relation.template operator()>("avm_binary", - Avm_vm::get_relation_label_avm_binary)) { - return false; - } if (!evaluate_logderivative.template operator()>("PERM_MAIN_ALU")) { return false; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index a9350ba2dd27..08c37288d85e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -46,16 +46,16 @@ class AvmFlavor { using RelationSeparator = FF; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2; - static constexpr size_t NUM_WITNESS_ENTITIES = 129; + static constexpr size_t NUM_WITNESS_ENTITIES = 131; 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 = 150; + static constexpr size_t NUM_ALL_ENTITIES = 152; using Relations = std::tuple, + Avm_vm::avm_binary, Avm_vm::avm_main, Avm_vm::avm_alu, - Avm_vm::avm_binary, perm_main_alu_relation, perm_main_bin_relation, perm_main_mem_a_relation, @@ -167,6 +167,8 @@ class AvmFlavor { avm_binary_start, avm_binary_mem_tag_ctr, avm_binary_mem_tag_ctr_inv, + avm_main_sel_rng_8, + avm_main_sel_rng_16, avm_main_pc, avm_main_internal_return_ptr, avm_main_sel_internal_call, @@ -299,6 +301,8 @@ class AvmFlavor { avm_binary_start, avm_binary_mem_tag_ctr, avm_binary_mem_tag_ctr_inv, + avm_main_sel_rng_8, + avm_main_sel_rng_16, avm_main_pc, avm_main_internal_return_ptr, avm_main_sel_internal_call, @@ -437,6 +441,8 @@ class AvmFlavor { avm_binary_start, avm_binary_mem_tag_ctr, avm_binary_mem_tag_ctr_inv, + avm_main_sel_rng_8, + avm_main_sel_rng_16, avm_main_pc, avm_main_internal_return_ptr, avm_main_sel_internal_call, @@ -496,25 +502,25 @@ class AvmFlavor { lookup_byte_operations_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, - avm_mem_m_rw_shift, avm_mem_m_tag_shift, - avm_mem_m_val_shift, + avm_mem_m_rw_shift, avm_mem_m_addr_shift, - avm_main_pc_shift, + avm_mem_m_val_shift, + avm_binary_acc_ic_shift, + avm_binary_op_id_shift, + avm_binary_acc_ib_shift, + avm_binary_mem_tag_ctr_shift, + avm_binary_acc_ia_shift, avm_main_internal_return_ptr_shift, - avm_alu_alu_u16_r2_shift, - avm_alu_alu_u16_r0_shift, - avm_alu_alu_u16_r3_shift, + avm_main_pc_shift, avm_alu_alu_u16_r1_shift, + avm_alu_alu_u16_r3_shift, + avm_alu_alu_u16_r2_shift, + avm_alu_alu_u16_r5_shift, avm_alu_alu_u16_r4_shift, - avm_alu_alu_u16_r7_shift, avm_alu_alu_u16_r6_shift, - avm_alu_alu_u16_r5_shift, - avm_binary_mem_tag_ctr_shift, - avm_binary_acc_ia_shift, - avm_binary_op_id_shift, - avm_binary_acc_ib_shift, - avm_binary_acc_ic_shift) + avm_alu_alu_u16_r0_shift, + avm_alu_alu_u16_r7_shift) RefVector get_wires() { @@ -590,6 +596,8 @@ class AvmFlavor { avm_binary_start, avm_binary_mem_tag_ctr, avm_binary_mem_tag_ctr_inv, + avm_main_sel_rng_8, + avm_main_sel_rng_16, avm_main_pc, avm_main_internal_return_ptr, avm_main_sel_internal_call, @@ -649,25 +657,25 @@ class AvmFlavor { lookup_byte_operations_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, - avm_mem_m_rw_shift, avm_mem_m_tag_shift, - avm_mem_m_val_shift, + avm_mem_m_rw_shift, avm_mem_m_addr_shift, - avm_main_pc_shift, + avm_mem_m_val_shift, + avm_binary_acc_ic_shift, + avm_binary_op_id_shift, + avm_binary_acc_ib_shift, + avm_binary_mem_tag_ctr_shift, + avm_binary_acc_ia_shift, avm_main_internal_return_ptr_shift, - avm_alu_alu_u16_r2_shift, - avm_alu_alu_u16_r0_shift, - avm_alu_alu_u16_r3_shift, + avm_main_pc_shift, avm_alu_alu_u16_r1_shift, + avm_alu_alu_u16_r3_shift, + avm_alu_alu_u16_r2_shift, + avm_alu_alu_u16_r5_shift, avm_alu_alu_u16_r4_shift, - avm_alu_alu_u16_r7_shift, avm_alu_alu_u16_r6_shift, - avm_alu_alu_u16_r5_shift, - avm_binary_mem_tag_ctr_shift, - avm_binary_acc_ia_shift, - avm_binary_op_id_shift, - avm_binary_acc_ib_shift, - avm_binary_acc_ic_shift }; + avm_alu_alu_u16_r0_shift, + avm_alu_alu_u16_r7_shift }; }; RefVector get_unshifted() { @@ -743,6 +751,8 @@ class AvmFlavor { avm_binary_start, avm_binary_mem_tag_ctr, avm_binary_mem_tag_ctr_inv, + avm_main_sel_rng_8, + avm_main_sel_rng_16, avm_main_pc, avm_main_internal_return_ptr, avm_main_sel_internal_call, @@ -805,23 +815,29 @@ class AvmFlavor { }; RefVector get_to_be_shifted() { - return { avm_mem_m_rw, avm_mem_m_tag, avm_mem_m_val, - avm_mem_m_addr, avm_main_pc, avm_main_internal_return_ptr, - avm_alu_alu_u16_r2, avm_alu_alu_u16_r0, avm_alu_alu_u16_r3, - avm_alu_alu_u16_r1, avm_alu_alu_u16_r4, avm_alu_alu_u16_r7, - avm_alu_alu_u16_r6, avm_alu_alu_u16_r5, avm_binary_mem_tag_ctr, - avm_binary_acc_ia, avm_binary_op_id, avm_binary_acc_ib, - avm_binary_acc_ic }; + return { avm_mem_m_tag, avm_mem_m_rw, + avm_mem_m_addr, avm_mem_m_val, + avm_binary_acc_ic, avm_binary_op_id, + avm_binary_acc_ib, avm_binary_mem_tag_ctr, + avm_binary_acc_ia, avm_main_internal_return_ptr, + avm_main_pc, avm_alu_alu_u16_r1, + avm_alu_alu_u16_r3, avm_alu_alu_u16_r2, + avm_alu_alu_u16_r5, avm_alu_alu_u16_r4, + avm_alu_alu_u16_r6, avm_alu_alu_u16_r0, + avm_alu_alu_u16_r7 }; }; RefVector get_shifted() { - return { avm_mem_m_rw_shift, avm_mem_m_tag_shift, avm_mem_m_val_shift, - avm_mem_m_addr_shift, avm_main_pc_shift, avm_main_internal_return_ptr_shift, - avm_alu_alu_u16_r2_shift, avm_alu_alu_u16_r0_shift, avm_alu_alu_u16_r3_shift, - avm_alu_alu_u16_r1_shift, avm_alu_alu_u16_r4_shift, avm_alu_alu_u16_r7_shift, - avm_alu_alu_u16_r6_shift, avm_alu_alu_u16_r5_shift, avm_binary_mem_tag_ctr_shift, - avm_binary_acc_ia_shift, avm_binary_op_id_shift, avm_binary_acc_ib_shift, - avm_binary_acc_ic_shift }; + return { avm_mem_m_tag_shift, avm_mem_m_rw_shift, + avm_mem_m_addr_shift, avm_mem_m_val_shift, + avm_binary_acc_ic_shift, avm_binary_op_id_shift, + avm_binary_acc_ib_shift, avm_binary_mem_tag_ctr_shift, + avm_binary_acc_ia_shift, avm_main_internal_return_ptr_shift, + avm_main_pc_shift, avm_alu_alu_u16_r1_shift, + avm_alu_alu_u16_r3_shift, avm_alu_alu_u16_r2_shift, + avm_alu_alu_u16_r5_shift, avm_alu_alu_u16_r4_shift, + avm_alu_alu_u16_r6_shift, avm_alu_alu_u16_r0_shift, + avm_alu_alu_u16_r7_shift }; }; }; @@ -834,13 +850,16 @@ class AvmFlavor { RefVector get_to_be_shifted() { - return { avm_mem_m_rw, avm_mem_m_tag, avm_mem_m_val, - avm_mem_m_addr, avm_main_pc, avm_main_internal_return_ptr, - avm_alu_alu_u16_r2, avm_alu_alu_u16_r0, avm_alu_alu_u16_r3, - avm_alu_alu_u16_r1, avm_alu_alu_u16_r4, avm_alu_alu_u16_r7, - avm_alu_alu_u16_r6, avm_alu_alu_u16_r5, avm_binary_mem_tag_ctr, - avm_binary_acc_ia, avm_binary_op_id, avm_binary_acc_ib, - avm_binary_acc_ic }; + return { avm_mem_m_tag, avm_mem_m_rw, + avm_mem_m_addr, avm_mem_m_val, + avm_binary_acc_ic, avm_binary_op_id, + avm_binary_acc_ib, avm_binary_mem_tag_ctr, + avm_binary_acc_ia, avm_main_internal_return_ptr, + avm_main_pc, avm_alu_alu_u16_r1, + avm_alu_alu_u16_r3, avm_alu_alu_u16_r2, + avm_alu_alu_u16_r5, avm_alu_alu_u16_r4, + avm_alu_alu_u16_r6, avm_alu_alu_u16_r0, + avm_alu_alu_u16_r7 }; }; // The plookup wires that store plookup read data. @@ -989,6 +1008,8 @@ class AvmFlavor { Base::avm_binary_start = "AVM_BINARY_START"; Base::avm_binary_mem_tag_ctr = "AVM_BINARY_MEM_TAG_CTR"; Base::avm_binary_mem_tag_ctr_inv = "AVM_BINARY_MEM_TAG_CTR_INV"; + Base::avm_main_sel_rng_8 = "AVM_MAIN_SEL_RNG_8"; + Base::avm_main_sel_rng_16 = "AVM_MAIN_SEL_RNG_16"; Base::avm_main_pc = "AVM_MAIN_PC"; Base::avm_main_internal_return_ptr = "AVM_MAIN_INTERNAL_RETURN_PTR"; Base::avm_main_sel_internal_call = "AVM_MAIN_SEL_INTERNAL_CALL"; @@ -1137,6 +1158,8 @@ class AvmFlavor { Commitment avm_binary_start; Commitment avm_binary_mem_tag_ctr; Commitment avm_binary_mem_tag_ctr_inv; + Commitment avm_main_sel_rng_8; + Commitment avm_main_sel_rng_16; Commitment avm_main_pc; Commitment avm_main_internal_return_ptr; Commitment avm_main_sel_internal_call; @@ -1286,6 +1309,8 @@ class AvmFlavor { avm_binary_start = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_binary_mem_tag_ctr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_binary_mem_tag_ctr_inv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_rng_8 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_rng_16 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_pc = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_internal_return_ptr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_internal_call = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -1438,6 +1463,8 @@ class AvmFlavor { serialize_to_buffer(avm_binary_start, Transcript::proof_data); serialize_to_buffer(avm_binary_mem_tag_ctr, Transcript::proof_data); serialize_to_buffer(avm_binary_mem_tag_ctr_inv, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_rng_8, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_rng_16, Transcript::proof_data); serialize_to_buffer(avm_main_pc, Transcript::proof_data); serialize_to_buffer(avm_main_internal_return_ptr, Transcript::proof_data); serialize_to_buffer(avm_main_sel_internal_call, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index f141e3544729..1d1a647e6f00 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -178,6 +178,10 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.avm_binary_mem_tag_ctr); commitments.avm_binary_mem_tag_ctr_inv = transcript->template receive_from_prover(commitment_labels.avm_binary_mem_tag_ctr_inv); + commitments.avm_main_sel_rng_8 = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_rng_8); + commitments.avm_main_sel_rng_16 = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_rng_16); commitments.avm_main_pc = transcript->template receive_from_prover(commitment_labels.avm_main_pc); commitments.avm_main_internal_return_ptr = transcript->template receive_from_prover(commitment_labels.avm_main_internal_return_ptr);