diff --git a/barretenberg/cpp/pil/avm/avm_main.pil b/barretenberg/cpp/pil/avm/avm_main.pil index 35870682abc..53cb8d86ccd 100644 --- a/barretenberg/cpp/pil/avm/avm_main.pil +++ b/barretenberg/cpp/pil/avm/avm_main.pil @@ -275,7 +275,7 @@ namespace avm_main(256); bin_sel = sel_op_and + sel_op_or + sel_op_xor; #[PERM_MAIN_BIN] - bin_sel {ia, ib, ic, bin_op_id, in_tag} + bin_sel {ia, ib, ic, bin_op_id, r_in_tag} is avm_binary.start {avm_binary.acc_ia, avm_binary.acc_ib, avm_binary.acc_ic, avm_binary.op_id, avm_binary.in_tag}; diff --git a/barretenberg/cpp/pil/avm/avm_mem.pil b/barretenberg/cpp/pil/avm/avm_mem.pil index cad02607461..fb23e57adcf 100644 --- a/barretenberg/cpp/pil/avm/avm_mem.pil +++ b/barretenberg/cpp/pil/avm/avm_mem.pil @@ -136,7 +136,7 @@ namespace avm_mem(256); m_rw * m_tag_err = 0; //====== Indirect Memory Constraints ===================================== - // Enforce r_in_tag == 3, i.e., in_tag must be U32 + // Enforce r_in_tag == 3, i.e., r_in_tag must be U32 m_ind_op_a * (r_in_tag - 3) = 0; m_ind_op_b * (r_in_tag - 3) = 0; m_ind_op_c * (r_in_tag - 3) = 0; @@ -146,7 +146,7 @@ namespace avm_mem(256); m_ind_op_b * m_rw = 0; m_ind_op_c * m_rw = 0; - //====== MOV Opcode in_tag Constraint ===================================== + //====== MOV Opcode Tag Constraint ===================================== // The following constraint ensures that the r_in_tag is set to m_tag for // the load operation pertaining to Ia. // The permutation check #[PERM_MAIN_MEM_A] guarantees that the r_in_tag 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 9cac63618dd..8fe200d9ff9 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp @@ -7,56 +7,50 @@ namespace bb::Avm_vm { template struct Avm_aluRow { - FF avm_alu_alu_u16_r5_shift{}; - FF avm_alu_alu_u16_r2{}; - FF avm_alu_alu_u16_r7_shift{}; - FF avm_alu_alu_u16_r7{}; + FF avm_alu_alu_in_tag{}; + FF avm_alu_alu_u16_r2_shift{}; FF avm_alu_alu_u8_tag{}; + 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_u32_tag{}; + 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_ib{}; - FF avm_alu_alu_u8_r0{}; - FF avm_alu_alu_u16_r0_shift{}; + FF avm_alu_alu_u16_r7_shift{}; + FF avm_alu_alu_ia{}; FF avm_alu_alu_op_sub{}; - FF avm_alu_alu_u16_r1{}; - FF avm_alu_alu_u16_r6{}; - FF avm_alu_alu_u16_r6_shift{}; - FF avm_alu_alu_u16_r2_shift{}; - FF avm_alu_alu_u16_r5{}; - FF avm_alu_alu_u32_tag{}; + FF avm_alu_alu_u8_r0{}; + FF avm_alu_alu_op_not{}; + FF avm_alu_alu_ff_tag{}; + FF avm_alu_alu_u16_r2{}; FF avm_alu_alu_u16_r4{}; FF avm_alu_alu_u8_r1{}; - FF avm_alu_alu_cf{}; - FF avm_alu_alu_sel{}; - FF avm_alu_alu_in_tag{}; - FF avm_alu_alu_ff_tag{}; - FF avm_alu_alu_op_eq_diff_inv{}; - FF avm_alu_alu_ia{}; - FF avm_alu_alu_ic{}; - FF avm_alu_alu_u128_tag{}; + 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_r1_shift{}; - FF avm_alu_alu_op_not{}; - FF avm_alu_alu_u16_r0{}; - FF avm_alu_alu_u16_r4_shift{}; - FF avm_alu_alu_u64_r0{}; - FF avm_alu_alu_op_eq{}; - FF avm_alu_alu_op_mul{}; - FF avm_alu_alu_u64_tag{}; + FF avm_alu_alu_u16_r5{}; + FF avm_alu_alu_ic{}; + FF avm_alu_alu_sel{}; }; inline std::string get_relation_label_avm_alu(int index) { switch (index) { - case 9: - return "ALU_ADD_SUB_1"; - - case 17: - return "ALU_FF_NOT_XOR"; - - case 18: - return "ALU_OP_NOT"; + case 13: + return "ALU_MUL_COMMON_2"; case 20: return "ALU_OP_EQ"; @@ -64,20 +58,26 @@ inline std::string get_relation_label_avm_alu(int index) case 11: return "ALU_MULTIPLICATION_FF"; - case 10: - return "ALU_ADD_SUB_2"; - case 19: return "ALU_RES_IS_BOOL"; - case 13: - return "ALU_MUL_COMMON_2"; + 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 18: + return "ALU_OP_NOT"; } 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 4d5179c6579..ee9948c94f1 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_binary.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_binary.hpp @@ -7,43 +7,43 @@ namespace bb::Avm_vm { template struct Avm_binaryRow { - FF avm_binary_bin_sel{}; - FF avm_binary_acc_ib{}; - FF avm_binary_mem_tag_ctr{}; + FF avm_binary_mem_tag_ctr_inv{}; FF avm_binary_bin_ic_bytes{}; - FF avm_binary_acc_ic_shift{}; FF avm_binary_acc_ia{}; - FF avm_binary_op_id_shift{}; + 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_op_id_shift{}; + FF avm_binary_bin_sel{}; + FF avm_binary_bin_ib_bytes{}; FF avm_binary_op_id{}; - FF avm_binary_mem_tag_ctr_shift{}; - FF avm_binary_acc_ic{}; FF avm_binary_bin_ia_bytes{}; - FF avm_binary_bin_ib_bytes{}; - FF avm_binary_mem_tag_ctr_inv{}; FF avm_binary_acc_ib_shift{}; + FF avm_binary_mem_tag_ctr{}; + FF avm_binary_acc_ic_shift{}; }; inline std::string get_relation_label_avm_binary(int index) { switch (index) { - case 1: - return "OP_ID_REL"; + case 9: + return "ACC_REL_C"; 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 9: - return "ACC_REL_C"; - case 3: return "BIN_SEL_CTR_REL"; - - case 2: - return "MEM_TAG_REL"; } return std::to_string(index); } 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 1dfdae74434..66d50ffe220 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp @@ -7,76 +7,90 @@ namespace bb::Avm_vm { template struct Avm_mainRow { - FF avm_main_mem_op_c{}; - FF avm_main_alu_sel{}; - FF avm_main_rwb{}; + 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_op_err{}; - FF avm_main_sel_internal_call{}; - FF avm_main_ic{}; - FF avm_main_sel_mov{}; + FF avm_main_r_in_tag{}; + FF avm_main_sel_op_and{}; + FF avm_main_sel_op_mul{}; + FF avm_main_mem_op_b{}; + FF avm_main_sel_op_or{}; + FF avm_main_mem_op_c{}; + FF avm_main_sel_halt{}; FF avm_main_inv{}; - FF avm_main_rwc{}; - FF avm_main_first{}; - FF avm_main_mem_op_a{}; - FF avm_main_sel_internal_return{}; - FF avm_main_pc_shift{}; - FF avm_main_sel_op_sub{}; - FF avm_main_ib{}; + FF avm_main_pc{}; FF avm_main_sel_op_not{}; - FF avm_main_sel_op_add{}; - FF avm_main_ind_op_c{}; - FF avm_main_ia{}; - FF avm_main_sel_halt{}; + FF avm_main_rwa{}; + FF avm_main_first{}; FF avm_main_sel_op_div{}; - FF avm_main_pc{}; - FF avm_main_sel_op_mul{}; - FF avm_main_mem_op_b{}; + 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_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_internal_return_ptr_shift{}; - FF avm_main_internal_return_ptr{}; FF avm_main_mem_idx_b{}; - FF avm_main_rwa{}; - FF avm_main_mem_idx_a{}; + 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_r_in_tag{}; - FF avm_main_w_in_tag{}; - FF avm_main_sel_jump{}; + 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{}; }; inline std::string get_relation_label_avm_main(int index) { switch (index) { - case 40: + 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 22: - return "SUBOP_DIVISION_FF"; + case 27: + return "SUBOP_DIVISION_ZERO_ERR1"; - case 38: + case 31: + return "RETURN_POINTER_INCREMENT"; + + case 42: return "PC_INCREMENT"; - case 33: + case 37: return "RETURN_POINTER_DECREMENT"; - case 23: - return "SUBOP_DIVISION_ZERO_ERR1"; - case 25: - return "SUBOP_ERROR_RELEVANT_OP"; + return "EQ_OUTPUT_U8"; - case 41: - return "MOV_MAIN_SAME_TAG"; + case 47: + return "BIN_SEL_1"; - case 39: - return "INTERNAL_RETURN_POINTER_CONSISTENCY"; + case 48: + return "BIN_SEL_2"; - case 27: - return "RETURN_POINTER_INCREMENT"; + case 26: + return "SUBOP_DIVISION_FF"; - case 24: - return "SUBOP_DIVISION_ZERO_ERR2"; + case 29: + return "SUBOP_ERROR_RELEVANT_OP"; } return std::to_string(index); } @@ -85,9 +99,9 @@ template class avm_mainImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 3, 3, 3, + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 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, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 3, 3, 3, 3, 2, }; template @@ -277,8 +291,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(22); - auto tmp = - ((avm_main_sel_op_div * (-avm_main_op_err + FF(1))) * ((avm_main_ic * avm_main_ib) - avm_main_ia)); + auto tmp = (avm_main_ind_op_a * (-avm_main_ind_op_a + FF(1))); tmp *= scaling_factor; std::get<22>(evals) += tmp; } @@ -286,7 +299,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(23); - auto tmp = (avm_main_sel_op_div * (((avm_main_ib * avm_main_inv) - FF(1)) + avm_main_op_err)); + auto tmp = (avm_main_ind_op_b * (-avm_main_ind_op_b + FF(1))); tmp *= scaling_factor; std::get<23>(evals) += tmp; } @@ -294,7 +307,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(24); - auto tmp = ((avm_main_sel_op_div * avm_main_op_err) * (-avm_main_inv + FF(1))); + auto tmp = (avm_main_ind_op_c * (-avm_main_ind_op_c + FF(1))); tmp *= scaling_factor; std::get<24>(evals) += tmp; } @@ -302,7 +315,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(25); - auto tmp = (avm_main_op_err * (avm_main_sel_op_div - FF(1))); + auto tmp = (avm_main_sel_op_eq * (avm_main_w_in_tag - FF(1))); tmp *= scaling_factor; std::get<25>(evals) += tmp; } @@ -310,7 +323,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(26); - auto tmp = (avm_main_sel_jump * (avm_main_pc_shift - avm_main_ia)); + auto tmp = + ((avm_main_sel_op_div * (-avm_main_op_err + FF(1))) * ((avm_main_ic * avm_main_ib) - avm_main_ia)); tmp *= scaling_factor; std::get<26>(evals) += tmp; } @@ -318,8 +332,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(27); - auto tmp = (avm_main_sel_internal_call * - (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr + FF(1)))); + auto tmp = (avm_main_sel_op_div * (((avm_main_ib * avm_main_inv) - FF(1)) + avm_main_op_err)); tmp *= scaling_factor; std::get<27>(evals) += tmp; } @@ -327,7 +340,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(28); - auto tmp = (avm_main_sel_internal_call * (avm_main_internal_return_ptr - avm_main_mem_idx_b)); + auto tmp = ((avm_main_sel_op_div * avm_main_op_err) * (-avm_main_inv + FF(1))); tmp *= scaling_factor; std::get<28>(evals) += tmp; } @@ -335,7 +348,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(29); - auto tmp = (avm_main_sel_internal_call * (avm_main_pc_shift - avm_main_ia)); + auto tmp = (avm_main_op_err * (avm_main_sel_op_div - FF(1))); tmp *= scaling_factor; std::get<29>(evals) += tmp; } @@ -343,7 +356,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(30); - auto tmp = (avm_main_sel_internal_call * ((avm_main_pc + FF(1)) - avm_main_ib)); + auto tmp = (avm_main_sel_jump * (avm_main_pc_shift - avm_main_ia)); tmp *= scaling_factor; std::get<30>(evals) += tmp; } @@ -351,7 +364,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(31); - auto tmp = (avm_main_sel_internal_call * (avm_main_rwb - FF(1))); + auto tmp = (avm_main_sel_internal_call * + (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr + FF(1)))); tmp *= scaling_factor; std::get<31>(evals) += tmp; } @@ -359,7 +373,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(32); - auto tmp = (avm_main_sel_internal_call * (avm_main_mem_op_b - FF(1))); + auto tmp = (avm_main_sel_internal_call * (avm_main_internal_return_ptr - avm_main_mem_idx_b)); tmp *= scaling_factor; std::get<32>(evals) += tmp; } @@ -367,8 +381,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(33); - auto tmp = (avm_main_sel_internal_return * - (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr - FF(1)))); + auto tmp = (avm_main_sel_internal_call * (avm_main_pc_shift - avm_main_ia)); tmp *= scaling_factor; std::get<33>(evals) += tmp; } @@ -376,7 +389,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(34); - auto tmp = (avm_main_sel_internal_return * ((avm_main_internal_return_ptr - FF(1)) - avm_main_mem_idx_a)); + auto tmp = (avm_main_sel_internal_call * ((avm_main_pc + FF(1)) - avm_main_ib)); tmp *= scaling_factor; std::get<34>(evals) += tmp; } @@ -384,7 +397,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(35); - auto tmp = (avm_main_sel_internal_return * (avm_main_pc_shift - avm_main_ia)); + auto tmp = (avm_main_sel_internal_call * (avm_main_rwb - FF(1))); tmp *= scaling_factor; std::get<35>(evals) += tmp; } @@ -392,7 +405,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(36); - auto tmp = (avm_main_sel_internal_return * avm_main_rwa); + auto tmp = (avm_main_sel_internal_call * (avm_main_mem_op_b - FF(1))); tmp *= scaling_factor; std::get<36>(evals) += tmp; } @@ -400,7 +413,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(37); - auto tmp = (avm_main_sel_internal_return * (avm_main_mem_op_a - FF(1))); + auto tmp = (avm_main_sel_internal_return * + (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr - FF(1)))); tmp *= scaling_factor; std::get<37>(evals) += tmp; } @@ -408,11 +422,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(38); - auto tmp = ((((-avm_main_first + FF(1)) * (-avm_main_sel_halt + FF(1))) * - (((((avm_main_sel_op_add + avm_main_sel_op_sub) + avm_main_sel_op_div) + avm_main_sel_op_mul) + - avm_main_sel_op_not) + - avm_main_sel_op_eq)) * - (avm_main_pc_shift - (avm_main_pc + FF(1)))); + auto tmp = (avm_main_sel_internal_return * ((avm_main_internal_return_ptr - FF(1)) - avm_main_mem_idx_a)); tmp *= scaling_factor; std::get<38>(evals) += tmp; } @@ -420,10 +430,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(39); - auto tmp = ((-(((avm_main_first + avm_main_sel_internal_call) + avm_main_sel_internal_return) + - avm_main_sel_halt) + - FF(1)) * - (avm_main_internal_return_ptr_shift - avm_main_internal_return_ptr)); + auto tmp = (avm_main_sel_internal_return * (avm_main_pc_shift - avm_main_ia)); tmp *= scaling_factor; std::get<39>(evals) += tmp; } @@ -431,7 +438,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(40); - auto tmp = (avm_main_sel_mov * (avm_main_ia - avm_main_ic)); + auto tmp = (avm_main_sel_internal_return * avm_main_rwa); tmp *= scaling_factor; std::get<40>(evals) += tmp; } @@ -439,7 +446,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(41); - auto tmp = (avm_main_sel_mov * (avm_main_r_in_tag - avm_main_w_in_tag)); + auto tmp = (avm_main_sel_internal_return * (avm_main_mem_op_a - FF(1))); tmp *= scaling_factor; std::get<41>(evals) += tmp; } @@ -447,12 +454,71 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(42); + auto tmp = + ((((-avm_main_first + FF(1)) * (-avm_main_sel_halt + FF(1))) * + ((((((((avm_main_sel_op_add + avm_main_sel_op_sub) + avm_main_sel_op_div) + avm_main_sel_op_mul) + + avm_main_sel_op_not) + + avm_main_sel_op_eq) + + avm_main_sel_op_and) + + avm_main_sel_op_or) + + avm_main_sel_op_xor)) * + (avm_main_pc_shift - (avm_main_pc + FF(1)))); + tmp *= scaling_factor; + std::get<42>(evals) += tmp; + } + // Contribution 43 + { + Avm_DECLARE_VIEWS(43); + + auto tmp = ((-(((avm_main_first + avm_main_sel_internal_call) + avm_main_sel_internal_return) + + avm_main_sel_halt) + + FF(1)) * + (avm_main_internal_return_ptr_shift - avm_main_internal_return_ptr)); + tmp *= scaling_factor; + std::get<43>(evals) += tmp; + } + // Contribution 44 + { + Avm_DECLARE_VIEWS(44); + + auto tmp = (avm_main_sel_mov * (avm_main_ia - avm_main_ic)); + tmp *= scaling_factor; + std::get<44>(evals) += tmp; + } + // Contribution 45 + { + Avm_DECLARE_VIEWS(45); + + auto tmp = (avm_main_sel_mov * (avm_main_r_in_tag - avm_main_w_in_tag)); + tmp *= scaling_factor; + std::get<45>(evals) += tmp; + } + // Contribution 46 + { + Avm_DECLARE_VIEWS(46); + auto tmp = (avm_main_alu_sel - (((((avm_main_sel_op_add + avm_main_sel_op_sub) + avm_main_sel_op_mul) + avm_main_sel_op_not) + avm_main_sel_op_eq) * (-avm_main_tag_err + FF(1)))); tmp *= scaling_factor; - std::get<42>(evals) += tmp; + std::get<46>(evals) += tmp; + } + // Contribution 47 + { + Avm_DECLARE_VIEWS(47); + + auto tmp = (avm_main_bin_op_id - (avm_main_sel_op_or + (avm_main_sel_op_xor * FF(2)))); + tmp *= scaling_factor; + std::get<47>(evals) += tmp; + } + // Contribution 48 + { + Avm_DECLARE_VIEWS(48); + + auto tmp = (avm_main_bin_sel - ((avm_main_sel_op_and + avm_main_sel_op_or) + avm_main_sel_op_xor)); + tmp *= scaling_factor; + std::get<48>(evals) += tmp; } } }; 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 fb3d0291219..6ea3004b2df 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_mem.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_mem.hpp @@ -7,62 +7,56 @@ namespace bb::Avm_vm { template struct Avm_memRow { - FF avm_mem_m_val_shift{}; - FF avm_mem_m_sel_mov{}; + FF avm_mem_m_op_b{}; + FF avm_mem_m_lastAccess{}; FF avm_mem_m_rw_shift{}; - FF avm_mem_m_addr_shift{}; - FF avm_mem_m_val{}; - FF avm_mem_m_sub_clk{}; FF avm_mem_m_ind_op_a{}; - FF avm_mem_m_lastAccess{}; - FF avm_mem_m_tag{}; - FF avm_mem_m_addr{}; - FF avm_mem_m_one_min_inv{}; FF avm_mem_m_ind_op_b{}; - FF avm_mem_m_tag_err{}; + 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_m_op_b{}; + FF avm_mem_w_in_tag{}; + FF avm_mem_m_addr_shift{}; + FF avm_mem_m_sel_mov{}; FF avm_mem_m_last{}; - FF avm_mem_r_in_tag{}; + FF avm_mem_m_tag_err{}; FF avm_mem_m_ind_op_c{}; - FF avm_mem_m_tag_shift{}; - FF avm_mem_w_in_tag{}; - FF avm_mem_m_op_a{}; }; inline std::string get_relation_label_avm_mem(int index) { switch (index) { - case 13: - return "MEM_READ_WRITE_VAL_CONSISTENCY"; - - case 17: - return "MEM_IN_TAG_CONSISTENCY_2"; + case 14: + return "MEM_READ_WRITE_TAG_CONSISTENCY"; - case 13: - return "MEM_READ_WRITE_VAL_CONSISTENCY"; + case 12: + return "MEM_LAST_ACCESS_DELIMITER"; case 19: return "NO_TAG_ERR_WRITE"; - case 12: - return "MEM_LAST_ACCESS_DELIMITER"; + case 13: + return "MEM_READ_WRITE_VAL_CONSISTENCY"; + + case 15: + return "MEM_ZERO_INIT"; case 26: return "MOV_SAME_TAG"; + case 17: + return "MEM_IN_TAG_CONSISTENCY_2"; + case 16: return "MEM_IN_TAG_CONSISTENCY_1"; - - case 15: - return "MEM_ZERO_INIT"; - - case 14: - return "MEM_READ_WRITE_TAG_CONSISTENCY"; - - case 13: - return "MEM_READ_WRITE_VAL_CONSISTENCY"; } 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 8ff29c49f71..8220b92dcb7 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -91,7 +91,9 @@ [[maybe_unused]] auto avm_main_sel_op_or = View(new_term.avm_main_sel_op_or); \ [[maybe_unused]] auto avm_main_sel_op_xor = View(new_term.avm_main_sel_op_xor); \ [[maybe_unused]] auto avm_main_alu_sel = View(new_term.avm_main_alu_sel); \ - [[maybe_unused]] auto avm_main_in_tag = View(new_term.avm_main_in_tag); \ + [[maybe_unused]] auto avm_main_bin_sel = View(new_term.avm_main_bin_sel); \ + [[maybe_unused]] auto avm_main_r_in_tag = View(new_term.avm_main_r_in_tag); \ + [[maybe_unused]] auto avm_main_w_in_tag = View(new_term.avm_main_w_in_tag); \ [[maybe_unused]] auto avm_main_op_err = View(new_term.avm_main_op_err); \ [[maybe_unused]] auto avm_main_tag_err = View(new_term.avm_main_tag_err); \ [[maybe_unused]] auto avm_main_inv = View(new_term.avm_main_inv); \ @@ -131,33 +133,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); \ -<<<<<<< HEAD - [[maybe_unused]] auto avm_main_internal_return_ptr_shift = View(new_term.avm_main_internal_return_ptr_shift); \ - [[maybe_unused]] auto avm_main_pc_shift = View(new_term.avm_main_pc_shift); \ -======= + [[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_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_main_internal_return_ptr_shift = View(new_term.avm_main_internal_return_ptr_shift); \ ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) - [[maybe_unused]] auto avm_mem_m_addr_shift = View(new_term.avm_mem_m_addr_shift); \ - [[maybe_unused]] auto avm_mem_m_val_shift = View(new_term.avm_mem_m_val_shift); \ - [[maybe_unused]] auto avm_mem_m_tag_shift = View(new_term.avm_mem_m_tag_shift); \ - [[maybe_unused]] auto avm_mem_m_rw_shift = View(new_term.avm_mem_m_rw_shift); \ -<<<<<<< HEAD - [[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_r1_shift = View(new_term.avm_alu_alu_u16_r1_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_r6_shift = View(new_term.avm_alu_alu_u16_r6_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_r4_shift = View(new_term.avm_alu_alu_u16_r4_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_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_r0_shift = View(new_term.avm_alu_alu_u16_r0_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_r3_shift = View(new_term.avm_alu_alu_u16_r3_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_r4_shift = View(new_term.avm_alu_alu_u16_r4_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_r7_shift = View(new_term.avm_alu_alu_u16_r7_shift); \ - [[maybe_unused]] auto avm_alu_alu_u16_r5_shift = View(new_term.avm_alu_alu_u16_r5_shift); ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) + [[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); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_bin.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_bin.hpp index 1c68236d82f..842f5812b4f 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_bin.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/perm_main_bin.hpp @@ -54,7 +54,7 @@ class perm_main_bin_permutation_settings { in.avm_main_ib, in.avm_main_ic, in.avm_main_bin_op_id, - in.avm_main_in_tag, + in.avm_main_r_in_tag, in.avm_binary_acc_ia, in.avm_binary_acc_ib, in.avm_binary_acc_ic, @@ -90,7 +90,7 @@ class perm_main_bin_permutation_settings { in.avm_main_ib, in.avm_main_ic, in.avm_main_bin_op_id, - in.avm_main_in_tag, + in.avm_main_r_in_tag, in.avm_binary_acc_ia, in.avm_binary_acc_ib, in.avm_binary_acc_ic, 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 e0cd48bc57c..49e6ac468f8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -482,8 +482,10 @@ void AvmTraceBuilder::op_and( bool tag_match = res.tag_match; // Reading from memory and loading into ia resp. ib. - auto read_a = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IA, res.direct_a_offset, in_tag); - auto read_b = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IB, res.direct_b_offset, in_tag); + auto read_a = + mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IA, res.direct_a_offset, in_tag, in_tag); + auto read_b = + mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IB, res.direct_b_offset, in_tag, in_tag); tag_match = read_a.tag_match && read_b.tag_match; FF a = tag_match ? read_a.val : FF(0); @@ -492,7 +494,7 @@ void AvmTraceBuilder::op_and( FF c = tag_match ? bin_trace_builder.op_and(a, b, in_tag, clk) : FF(0); // Write into memory value c from intermediate register ic. - mem_trace_builder.write_into_memory(clk, IntermRegister::IC, res.direct_dst_offset, c, in_tag); + mem_trace_builder.write_into_memory(clk, IntermRegister::IC, res.direct_dst_offset, c, in_tag, in_tag); main_trace.push_back(Row{ .avm_main_clk = clk, @@ -500,7 +502,8 @@ void AvmTraceBuilder::op_and( .avm_main_internal_return_ptr = FF(internal_return_ptr), .avm_main_sel_op_and = FF(1), .avm_main_bin_sel = FF(1), - .avm_main_in_tag = FF(static_cast(in_tag)), + .avm_main_r_in_tag = FF(static_cast(in_tag)), + .avm_main_w_in_tag = FF(static_cast(in_tag)), .avm_main_tag_err = FF(static_cast(!tag_match)), .avm_main_ia = a, .avm_main_ib = b, @@ -531,8 +534,10 @@ void AvmTraceBuilder::op_or( bool tag_match = res.tag_match; // Reading from memory and loading into ia resp. ib. - auto read_a = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IA, res.direct_a_offset, in_tag); - auto read_b = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IB, res.direct_b_offset, in_tag); + auto read_a = + mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IA, res.direct_a_offset, in_tag, in_tag); + auto read_b = + mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IB, res.direct_b_offset, in_tag, in_tag); tag_match = read_a.tag_match && read_b.tag_match; FF a = tag_match ? read_a.val : FF(0); @@ -541,7 +546,7 @@ void AvmTraceBuilder::op_or( FF c = tag_match ? bin_trace_builder.op_or(a, b, in_tag, clk) : FF(0); // Write into memory value c from intermediate register ic. - mem_trace_builder.write_into_memory(clk, IntermRegister::IC, res.direct_dst_offset, c, in_tag); + mem_trace_builder.write_into_memory(clk, IntermRegister::IC, res.direct_dst_offset, c, in_tag, in_tag); main_trace.push_back(Row{ .avm_main_clk = clk, @@ -549,7 +554,8 @@ void AvmTraceBuilder::op_or( .avm_main_internal_return_ptr = FF(internal_return_ptr), .avm_main_sel_op_or = FF(1), .avm_main_bin_sel = FF(1), - .avm_main_in_tag = FF(static_cast(in_tag)), + .avm_main_r_in_tag = FF(static_cast(in_tag)), + .avm_main_w_in_tag = FF(static_cast(in_tag)), .avm_main_tag_err = FF(static_cast(!tag_match)), .avm_main_ia = a, .avm_main_ib = b, @@ -580,8 +586,10 @@ void AvmTraceBuilder::op_xor( bool tag_match = res.tag_match; // Reading from memory and loading into ia resp. ib. - auto read_a = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IA, res.direct_a_offset, in_tag); - auto read_b = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IB, res.direct_b_offset, in_tag); + auto read_a = + mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IA, res.direct_a_offset, in_tag, in_tag); + auto read_b = + mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::IB, res.direct_b_offset, in_tag, in_tag); tag_match = read_a.tag_match && read_b.tag_match; FF a = tag_match ? read_a.val : FF(0); @@ -590,7 +598,7 @@ void AvmTraceBuilder::op_xor( FF c = tag_match ? bin_trace_builder.op_xor(a, b, in_tag, clk) : FF(0); // Write into memory value c from intermediate register ic. - mem_trace_builder.write_into_memory(clk, IntermRegister::IC, res.direct_dst_offset, c, in_tag); + mem_trace_builder.write_into_memory(clk, IntermRegister::IC, res.direct_dst_offset, c, in_tag, in_tag); main_trace.push_back(Row{ .avm_main_clk = clk, @@ -598,7 +606,8 @@ void AvmTraceBuilder::op_xor( .avm_main_internal_return_ptr = FF(internal_return_ptr), .avm_main_sel_op_xor = FF(1), .avm_main_bin_sel = FF(1), - .avm_main_in_tag = FF(static_cast(in_tag)), + .avm_main_r_in_tag = FF(static_cast(in_tag)), + .avm_main_w_in_tag = FF(static_cast(in_tag)), .avm_main_tag_err = FF(static_cast(!tag_match)), .avm_main_ia = a, .avm_main_ib = b, 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 27dff642736..f647cf2fc29 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -121,7 +121,9 @@ template struct AvmFullRow { FF avm_main_sel_op_or{}; FF avm_main_sel_op_xor{}; FF avm_main_alu_sel{}; - FF avm_main_in_tag{}; + FF avm_main_bin_sel{}; + FF avm_main_r_in_tag{}; + FF avm_main_w_in_tag{}; FF avm_main_op_err{}; FF avm_main_tag_err{}; FF avm_main_inv{}; @@ -161,36 +163,25 @@ template struct AvmFullRow { FF lookup_byte_operations_counts{}; FF incl_main_tag_err_counts{}; FF incl_mem_tag_err_counts{}; -<<<<<<< HEAD - FF avm_main_internal_return_ptr_shift{}; - FF avm_main_pc_shift{}; -======= + FF avm_mem_m_rw_shift{}; + FF avm_mem_m_tag_shift{}; + FF avm_mem_m_val_shift{}; + FF avm_mem_m_addr_shift{}; FF avm_main_pc_shift{}; FF avm_main_internal_return_ptr_shift{}; ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) - FF avm_mem_m_addr_shift{}; - FF avm_mem_m_val_shift{}; - FF avm_mem_m_tag_shift{}; - FF avm_mem_m_rw_shift{}; -<<<<<<< HEAD - FF avm_alu_alu_u16_r7_shift{}; - FF avm_alu_alu_u16_r1_shift{}; - FF avm_alu_alu_u16_r5_shift{}; - FF avm_alu_alu_u16_r6_shift{}; - FF avm_alu_alu_u16_r0_shift{}; - FF avm_alu_alu_u16_r4_shift{}; - FF avm_alu_alu_u16_r2_shift{}; - FF avm_alu_alu_u16_r3_shift{}; -======= FF avm_alu_alu_u16_r2_shift{}; FF avm_alu_alu_u16_r0_shift{}; - FF avm_alu_alu_u16_r6_shift{}; + FF avm_alu_alu_u16_r3_shift{}; FF avm_alu_alu_u16_r1_shift{}; FF avm_alu_alu_u16_r4_shift{}; - FF avm_alu_alu_u16_r3_shift{}; FF avm_alu_alu_u16_r7_shift{}; + FF avm_alu_alu_u16_r6_shift{}; FF avm_alu_alu_u16_r5_shift{}; ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) + 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{}; }; class AvmCircuitBuilder { @@ -203,8 +194,8 @@ class AvmCircuitBuilder { using Polynomial = Flavor::Polynomial; using ProverPolynomials = Flavor::ProverPolynomials; - static constexpr size_t num_fixed_columns = 113; - static constexpr size_t num_polys = 99; + static constexpr size_t num_fixed_columns = 150; + static constexpr size_t num_polys = 131; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -309,7 +300,9 @@ class AvmCircuitBuilder { polys.avm_main_sel_op_or[i] = rows[i].avm_main_sel_op_or; polys.avm_main_sel_op_xor[i] = rows[i].avm_main_sel_op_xor; polys.avm_main_alu_sel[i] = rows[i].avm_main_alu_sel; - polys.avm_main_in_tag[i] = rows[i].avm_main_in_tag; + polys.avm_main_bin_sel[i] = rows[i].avm_main_bin_sel; + polys.avm_main_r_in_tag[i] = rows[i].avm_main_r_in_tag; + polys.avm_main_w_in_tag[i] = rows[i].avm_main_w_in_tag; polys.avm_main_op_err[i] = rows[i].avm_main_op_err; polys.avm_main_tag_err[i] = rows[i].avm_main_tag_err; polys.avm_main_inv[i] = rows[i].avm_main_inv; @@ -351,36 +344,25 @@ class AvmCircuitBuilder { polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; } -<<<<<<< HEAD - polys.avm_main_internal_return_ptr_shift = Polynomial(polys.avm_main_internal_return_ptr.shifted()); - polys.avm_main_pc_shift = Polynomial(polys.avm_main_pc.shifted()); -======= + 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_addr_shift = Polynomial(polys.avm_mem_m_addr.shifted()); polys.avm_main_pc_shift = Polynomial(polys.avm_main_pc.shifted()); polys.avm_main_internal_return_ptr_shift = Polynomial(polys.avm_main_internal_return_ptr.shifted()); ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) - polys.avm_mem_m_addr_shift = Polynomial(polys.avm_mem_m_addr.shifted()); - polys.avm_mem_m_val_shift = Polynomial(polys.avm_mem_m_val.shifted()); - polys.avm_mem_m_tag_shift = Polynomial(polys.avm_mem_m_tag.shifted()); - polys.avm_mem_m_rw_shift = Polynomial(polys.avm_mem_m_rw.shifted()); -<<<<<<< HEAD - polys.avm_alu_alu_u16_r7_shift = Polynomial(polys.avm_alu_alu_u16_r7.shifted()); - polys.avm_alu_alu_u16_r1_shift = Polynomial(polys.avm_alu_alu_u16_r1.shifted()); - polys.avm_alu_alu_u16_r5_shift = Polynomial(polys.avm_alu_alu_u16_r5.shifted()); - polys.avm_alu_alu_u16_r6_shift = Polynomial(polys.avm_alu_alu_u16_r6.shifted()); - polys.avm_alu_alu_u16_r0_shift = Polynomial(polys.avm_alu_alu_u16_r0.shifted()); - polys.avm_alu_alu_u16_r4_shift = Polynomial(polys.avm_alu_alu_u16_r4.shifted()); - polys.avm_alu_alu_u16_r2_shift = Polynomial(polys.avm_alu_alu_u16_r2.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_r0_shift = Polynomial(polys.avm_alu_alu_u16_r0.shifted()); - polys.avm_alu_alu_u16_r6_shift = Polynomial(polys.avm_alu_alu_u16_r6.shifted()); + polys.avm_alu_alu_u16_r3_shift = Polynomial(polys.avm_alu_alu_u16_r3.shifted()); polys.avm_alu_alu_u16_r1_shift = Polynomial(polys.avm_alu_alu_u16_r1.shifted()); polys.avm_alu_alu_u16_r4_shift = Polynomial(polys.avm_alu_alu_u16_r4.shifted()); - polys.avm_alu_alu_u16_r3_shift = Polynomial(polys.avm_alu_alu_u16_r3.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()); ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) + 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()); return polys; } @@ -452,18 +434,22 @@ class AvmCircuitBuilder { return true; }; - if (!evaluate_relation.template operator()>("avm_main", - Avm_vm::get_relation_label_avm_main)) { - return false; - } if (!evaluate_relation.template operator()>("avm_mem", Avm_vm::get_relation_label_avm_mem)) { return false; } + if (!evaluate_relation.template operator()>("avm_main", + Avm_vm::get_relation_label_avm_main)) { + return false; + } if (!evaluate_relation.template operator()>("avm_alu", 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 20aebe569f0..a9350ba2dd2 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -46,15 +46,16 @@ class AvmFlavor { using RelationSeparator = FF; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2; - static constexpr size_t NUM_WITNESS_ENTITIES = 97; + static constexpr size_t NUM_WITNESS_ENTITIES = 129; 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 = 113; + static constexpr size_t NUM_ALL_ENTITIES = 150; - using Relations = std::tuple, - Avm_vm::avm_mem, + using Relations = std::tuple, + 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, @@ -183,7 +184,9 @@ class AvmFlavor { avm_main_sel_op_or, avm_main_sel_op_xor, avm_main_alu_sel, - avm_main_in_tag, + avm_main_bin_sel, + avm_main_r_in_tag, + avm_main_w_in_tag, avm_main_op_err, avm_main_tag_err, avm_main_inv, @@ -313,7 +316,9 @@ class AvmFlavor { avm_main_sel_op_or, avm_main_sel_op_xor, avm_main_alu_sel, - avm_main_in_tag, + avm_main_bin_sel, + avm_main_r_in_tag, + avm_main_w_in_tag, avm_main_op_err, avm_main_tag_err, avm_main_inv, @@ -449,7 +454,9 @@ class AvmFlavor { avm_main_sel_op_or, avm_main_sel_op_xor, avm_main_alu_sel, - avm_main_in_tag, + avm_main_bin_sel, + avm_main_r_in_tag, + avm_main_w_in_tag, avm_main_op_err, avm_main_tag_err, avm_main_inv, @@ -489,36 +496,25 @@ class AvmFlavor { lookup_byte_operations_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, -<<<<<<< HEAD - avm_main_internal_return_ptr_shift, - avm_main_pc_shift, -======= + 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, ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) - avm_mem_m_addr_shift, - avm_mem_m_val_shift, - avm_mem_m_tag_shift, - avm_mem_m_rw_shift, -<<<<<<< HEAD - avm_alu_alu_u16_r7_shift, - avm_alu_alu_u16_r1_shift, - avm_alu_alu_u16_r5_shift, - avm_alu_alu_u16_r6_shift, - avm_alu_alu_u16_r0_shift, - avm_alu_alu_u16_r4_shift, - avm_alu_alu_u16_r2_shift, - avm_alu_alu_u16_r3_shift) -======= avm_alu_alu_u16_r2_shift, avm_alu_alu_u16_r0_shift, - avm_alu_alu_u16_r6_shift, + avm_alu_alu_u16_r3_shift, avm_alu_alu_u16_r1_shift, avm_alu_alu_u16_r4_shift, - avm_alu_alu_u16_r3_shift, avm_alu_alu_u16_r7_shift, - avm_alu_alu_u16_r5_shift) ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) + 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) RefVector get_wires() { @@ -611,7 +607,9 @@ class AvmFlavor { avm_main_sel_op_or, avm_main_sel_op_xor, avm_main_alu_sel, - avm_main_in_tag, + avm_main_bin_sel, + avm_main_r_in_tag, + avm_main_w_in_tag, avm_main_op_err, avm_main_tag_err, avm_main_inv, @@ -651,36 +649,25 @@ class AvmFlavor { lookup_byte_operations_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, -<<<<<<< HEAD - avm_main_internal_return_ptr_shift, - avm_main_pc_shift, -======= + 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, ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) - avm_mem_m_addr_shift, - avm_mem_m_val_shift, - avm_mem_m_tag_shift, - avm_mem_m_rw_shift, -<<<<<<< HEAD - avm_alu_alu_u16_r7_shift, - avm_alu_alu_u16_r1_shift, - avm_alu_alu_u16_r5_shift, - avm_alu_alu_u16_r6_shift, - avm_alu_alu_u16_r0_shift, - avm_alu_alu_u16_r4_shift, - avm_alu_alu_u16_r2_shift, - avm_alu_alu_u16_r3_shift }; -======= avm_alu_alu_u16_r2_shift, avm_alu_alu_u16_r0_shift, - avm_alu_alu_u16_r6_shift, + avm_alu_alu_u16_r3_shift, avm_alu_alu_u16_r1_shift, avm_alu_alu_u16_r4_shift, - avm_alu_alu_u16_r3_shift, avm_alu_alu_u16_r7_shift, - avm_alu_alu_u16_r5_shift }; ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) + 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 }; }; RefVector get_unshifted() { @@ -773,7 +760,9 @@ class AvmFlavor { avm_main_sel_op_or, avm_main_sel_op_xor, avm_main_alu_sel, - avm_main_in_tag, + avm_main_bin_sel, + avm_main_r_in_tag, + avm_main_w_in_tag, avm_main_op_err, avm_main_tag_err, avm_main_inv, @@ -816,57 +805,23 @@ class AvmFlavor { }; RefVector get_to_be_shifted() { -<<<<<<< HEAD - return { avm_main_internal_return_ptr, - avm_main_pc, - avm_mem_m_addr, - avm_mem_m_val, - avm_mem_m_tag, - avm_mem_m_rw, - avm_alu_alu_u16_r7, - avm_alu_alu_u16_r1, - avm_alu_alu_u16_r5, - avm_alu_alu_u16_r6, - avm_alu_alu_u16_r0, - avm_alu_alu_u16_r4, - avm_alu_alu_u16_r2, - avm_alu_alu_u16_r3 }; + 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 }; }; RefVector get_shifted() { - return { avm_main_internal_return_ptr_shift, - avm_main_pc_shift, - avm_mem_m_addr_shift, - avm_mem_m_val_shift, - avm_mem_m_tag_shift, - avm_mem_m_rw_shift, - avm_alu_alu_u16_r7_shift, - avm_alu_alu_u16_r1_shift, - avm_alu_alu_u16_r5_shift, - avm_alu_alu_u16_r6_shift, - avm_alu_alu_u16_r0_shift, - avm_alu_alu_u16_r4_shift, - avm_alu_alu_u16_r2_shift, - avm_alu_alu_u16_r3_shift }; -======= - return { avm_main_pc, avm_main_internal_return_ptr, - avm_mem_m_addr, avm_mem_m_val, - avm_mem_m_tag, avm_mem_m_rw, - avm_alu_alu_u16_r2, avm_alu_alu_u16_r0, - avm_alu_alu_u16_r6, avm_alu_alu_u16_r1, - avm_alu_alu_u16_r4, avm_alu_alu_u16_r3, - avm_alu_alu_u16_r7, avm_alu_alu_u16_r5 }; - }; - RefVector get_shifted() - { - return { avm_main_pc_shift, avm_main_internal_return_ptr_shift, - avm_mem_m_addr_shift, avm_mem_m_val_shift, - avm_mem_m_tag_shift, avm_mem_m_rw_shift, - avm_alu_alu_u16_r2_shift, avm_alu_alu_u16_r0_shift, - avm_alu_alu_u16_r6_shift, avm_alu_alu_u16_r1_shift, - avm_alu_alu_u16_r4_shift, avm_alu_alu_u16_r3_shift, - avm_alu_alu_u16_r7_shift, avm_alu_alu_u16_r5_shift }; ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) + 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 }; }; }; @@ -879,30 +834,13 @@ class AvmFlavor { RefVector get_to_be_shifted() { -<<<<<<< HEAD - return { avm_main_internal_return_ptr, - avm_main_pc, - avm_mem_m_addr, - avm_mem_m_val, - avm_mem_m_tag, - avm_mem_m_rw, - avm_alu_alu_u16_r7, - avm_alu_alu_u16_r1, - avm_alu_alu_u16_r5, - avm_alu_alu_u16_r6, - avm_alu_alu_u16_r0, - avm_alu_alu_u16_r4, - avm_alu_alu_u16_r2, - avm_alu_alu_u16_r3 }; -======= - return { avm_main_pc, avm_main_internal_return_ptr, - avm_mem_m_addr, avm_mem_m_val, - avm_mem_m_tag, avm_mem_m_rw, - avm_alu_alu_u16_r2, avm_alu_alu_u16_r0, - avm_alu_alu_u16_r6, avm_alu_alu_u16_r1, - avm_alu_alu_u16_r4, avm_alu_alu_u16_r3, - avm_alu_alu_u16_r7, avm_alu_alu_u16_r5 }; ->>>>>>> 6c8f4b1ab (5290 - add constraint on eq output being u8 and unit tests) + 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 }; }; // The plookup wires that store plookup read data. @@ -1068,7 +1006,9 @@ class AvmFlavor { Base::avm_main_sel_op_or = "AVM_MAIN_SEL_OP_OR"; Base::avm_main_sel_op_xor = "AVM_MAIN_SEL_OP_XOR"; Base::avm_main_alu_sel = "AVM_MAIN_ALU_SEL"; - Base::avm_main_in_tag = "AVM_MAIN_IN_TAG"; + Base::avm_main_bin_sel = "AVM_MAIN_BIN_SEL"; + Base::avm_main_r_in_tag = "AVM_MAIN_R_IN_TAG"; + Base::avm_main_w_in_tag = "AVM_MAIN_W_IN_TAG"; Base::avm_main_op_err = "AVM_MAIN_OP_ERR"; Base::avm_main_tag_err = "AVM_MAIN_TAG_ERR"; Base::avm_main_inv = "AVM_MAIN_INV"; @@ -1214,7 +1154,9 @@ class AvmFlavor { Commitment avm_main_sel_op_or; Commitment avm_main_sel_op_xor; Commitment avm_main_alu_sel; - Commitment avm_main_in_tag; + Commitment avm_main_bin_sel; + Commitment avm_main_r_in_tag; + Commitment avm_main_w_in_tag; Commitment avm_main_op_err; Commitment avm_main_tag_err; Commitment avm_main_inv; @@ -1361,7 +1303,9 @@ class AvmFlavor { avm_main_sel_op_or = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_xor = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_alu_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - avm_main_in_tag = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_bin_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_r_in_tag = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_w_in_tag = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_op_err = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_tag_err = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_inv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -1511,7 +1455,9 @@ class AvmFlavor { serialize_to_buffer(avm_main_sel_op_or, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_xor, Transcript::proof_data); serialize_to_buffer(avm_main_alu_sel, Transcript::proof_data); - serialize_to_buffer(avm_main_in_tag, Transcript::proof_data); + serialize_to_buffer(avm_main_bin_sel, Transcript::proof_data); + serialize_to_buffer(avm_main_r_in_tag, Transcript::proof_data); + serialize_to_buffer(avm_main_w_in_tag, Transcript::proof_data); serialize_to_buffer(avm_main_op_err, Transcript::proof_data); serialize_to_buffer(avm_main_tag_err, Transcript::proof_data); serialize_to_buffer(avm_main_inv, 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 db48a3163f4..f141e354472 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -211,8 +211,12 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_xor); commitments.avm_main_alu_sel = transcript->template receive_from_prover(commitment_labels.avm_main_alu_sel); - commitments.avm_main_in_tag = - transcript->template receive_from_prover(commitment_labels.avm_main_in_tag); + commitments.avm_main_bin_sel = + transcript->template receive_from_prover(commitment_labels.avm_main_bin_sel); + commitments.avm_main_r_in_tag = + transcript->template receive_from_prover(commitment_labels.avm_main_r_in_tag); + commitments.avm_main_w_in_tag = + transcript->template receive_from_prover(commitment_labels.avm_main_w_in_tag); commitments.avm_main_op_err = transcript->template receive_from_prover(commitment_labels.avm_main_op_err); commitments.avm_main_tag_err = diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp index 93f2e08d29c..b73ebc729cd 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp @@ -131,8 +131,9 @@ void common_validate_bit_op(std::vector const& trace, EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_rwb, FF(0)); - // Check the instruction tag - EXPECT_EQ(row->avm_main_in_tag, FF(static_cast(tag))); + // Check the instruction tags + EXPECT_EQ(row->avm_main_r_in_tag, FF(static_cast(tag))); + EXPECT_EQ(row->avm_main_w_in_tag, FF(static_cast(tag))); // Check that start row is the same as what is copied into the main trace EXPECT_EQ(bin_row_start->avm_binary_acc_ia, a); @@ -168,6 +169,7 @@ enum BIT_FAILURES { ByteLengthError, IncorrectBinSelector, }; + std::vector gen_mutated_trace_bit(std::vector trace, std::function&& select_row, FF const& c_mutated,