From d3b3ccd4f73c8c391337c41b994f381aecb3a0bc Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 14 Dec 2023 18:15:34 +0000 Subject: [PATCH 01/10] feat: call and return pil --- barretenberg/cpp/pil/avm/avm_mini.pil | 37 +++++- .../flavor/generated/AvmMini_flavor.hpp | 98 ++++++++------ .../generated/AvmMini_circuit_builder.hpp | 32 +++-- .../relations/generated/AvmMini/avm_mini.hpp | 122 ++++++++++++++++-- .../generated/AvmMini/declare_views.hpp | 8 +- .../relations/generated/AvmMini/mem_trace.hpp | 14 +- .../vm/generated/AvmMini_composer.cpp | 4 + .../vm/generated/AvmMini_prover.cpp | 14 +- .../vm/generated/AvmMini_verifier.cpp | 7 + 9 files changed, 272 insertions(+), 64 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index 3bd9bc11b866..e2bbc8041136 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -7,6 +7,16 @@ namespace avmMini(256); pol constant clk(i) { i }; pol constant first = [1] + [0]*; // Used mostly to toggle off the first row consisting // only in first element of shifted polynomials. + + //===== CONTROL FLOW ========================================================== + // Program counter + pol commit pc; + // Return Pointer + pol commit ret_ptr; + + pol commit sel_jump; + pol commit sel_ret; + //===== TABLE SUBOP-TR ======================================================== // Boolean selectors for (sub-)operations. Only one operation is activated at @@ -108,4 +118,29 @@ namespace avmMini(256); // Same for the relations related to the error activation: // (ib * inv - 1 + op_div_err) = 0 && op_err * (1 - inv) = 0 // This works in combination with op_div_err * (sel_op_div - 1) = 0; - // Drawback is the need to paralllelize the latter. \ No newline at end of file + // Drawback is the need to paralllelize the latter. + + + //===== JUMP_RETURN ======================================================== + // The program counter in the next row should be equal to the value loaded from the ia register + // This implies that a load from memory must occur at the same time + // Imply that we must load the jump selector into mema + sel_jump * (ret_ptr' - (ret_ptr + 1)) = 0; // we increment our jump selector + sel_jump * (ret_ptr - mem_idx_a) = 0; + sel_jump * (rwa - 1) = 0; // it must be a write + sel_jump * (mem_op_a - 1) = 0; + sel_jump * (pc' - ia) = 0; + + // We must load the memory pointer to be the ret_ptr + sel_ret * (ret_ptr' - (ret_ptr - 1)) = 0; // We decrement out jump selector + sel_ret * (ret_ptr - mem_idx_a) = 0; + sel_ret * (pc' - ia) = 0; + sel_ret * rwa = 0; + sel_ret * (mem_op_a - 1) = 0; + + // Program counter must increment if not jumping or returning + (1 - sel_jump) * (1- sel_ret) * (pc' - (pc + 1)) = 0; + + + // TODO: we want to set an initial number for the reserved memory of the jump pointer + diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp index c2b4e385c8f1..add1c64ce644 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp @@ -36,11 +36,11 @@ class AvmMiniFlavor { using VerifierCommitmentKey = pcs::VerifierCommitmentKey; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2; - static constexpr size_t NUM_WITNESS_ENTITIES = 25; + static constexpr size_t NUM_WITNESS_ENTITIES = 29; 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 = 30; + static constexpr size_t NUM_ALL_ENTITIES = 36; using Relations = std::tuple, AvmMini_vm::avm_mini>; @@ -82,6 +82,10 @@ class AvmMiniFlavor { memTrace_m_val, memTrace_m_lastAccess, memTrace_m_rw, + avmMini_pc, + avmMini_ret_ptr, + avmMini_sel_jump, + avmMini_sel_ret, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -105,11 +109,12 @@ class AvmMiniFlavor { RefVector get_wires() { return { - memTrace_m_clk, memTrace_m_sub_clk, memTrace_m_addr, memTrace_m_val, memTrace_m_lastAccess, - memTrace_m_rw, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, avmMini_sel_op_div, - avmMini_op_err, avmMini_inv, avmMini_ia, avmMini_ib, avmMini_ic, - avmMini_mem_op_a, avmMini_mem_op_b, avmMini_mem_op_c, avmMini_rwa, avmMini_rwb, - avmMini_rwc, avmMini_mem_idx_a, avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last + memTrace_m_clk, memTrace_m_sub_clk, memTrace_m_addr, memTrace_m_val, memTrace_m_lastAccess, + memTrace_m_rw, avmMini_pc, avmMini_ret_ptr, avmMini_sel_jump, avmMini_sel_ret, + avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, avmMini_sel_op_div, avmMini_op_err, + avmMini_inv, avmMini_ia, avmMini_ib, avmMini_ic, avmMini_mem_op_a, + avmMini_mem_op_b, avmMini_mem_op_c, avmMini_rwa, avmMini_rwb, avmMini_rwc, + avmMini_mem_idx_a, avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last }; }; RefVector get_sorted_polynomials() { return {}; }; @@ -126,6 +131,10 @@ class AvmMiniFlavor { memTrace_m_val, memTrace_m_lastAccess, memTrace_m_rw, + avmMini_pc, + avmMini_ret_ptr, + avmMini_sel_jump, + avmMini_sel_ret, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -145,9 +154,11 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, + memTrace_m_val_shift, memTrace_m_rw_shift, memTrace_m_addr_shift, - memTrace_m_val_shift) + avmMini_ret_ptr_shift, + avmMini_pc_shift) RefVector get_wires() { @@ -159,6 +170,10 @@ class AvmMiniFlavor { memTrace_m_val, memTrace_m_lastAccess, memTrace_m_rw, + avmMini_pc, + avmMini_ret_ptr, + avmMini_sel_jump, + avmMini_sel_ret, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -178,44 +193,35 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, + memTrace_m_val_shift, memTrace_m_rw_shift, memTrace_m_addr_shift, - memTrace_m_val_shift }; + avmMini_ret_ptr_shift, + avmMini_pc_shift }; }; RefVector get_unshifted() { - return { avmMini_clk, - avmMini_first, - memTrace_m_clk, - memTrace_m_sub_clk, - memTrace_m_addr, - memTrace_m_val, - memTrace_m_lastAccess, - memTrace_m_rw, - avmMini_sel_op_add, - avmMini_sel_op_sub, - avmMini_sel_op_mul, - avmMini_sel_op_div, - avmMini_op_err, - avmMini_inv, - avmMini_ia, - avmMini_ib, - avmMini_ic, - avmMini_mem_op_a, - avmMini_mem_op_b, - avmMini_mem_op_c, - avmMini_rwa, - avmMini_rwb, - avmMini_rwc, - avmMini_mem_idx_a, - avmMini_mem_idx_b, - avmMini_mem_idx_c, - avmMini_last }; + return { + avmMini_clk, avmMini_first, memTrace_m_clk, memTrace_m_sub_clk, memTrace_m_addr, + memTrace_m_val, memTrace_m_lastAccess, memTrace_m_rw, avmMini_pc, avmMini_ret_ptr, + avmMini_sel_jump, avmMini_sel_ret, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, + avmMini_sel_op_div, avmMini_op_err, avmMini_inv, avmMini_ia, avmMini_ib, + avmMini_ic, avmMini_mem_op_a, avmMini_mem_op_b, avmMini_mem_op_c, avmMini_rwa, + avmMini_rwb, avmMini_rwc, avmMini_mem_idx_a, avmMini_mem_idx_b, avmMini_mem_idx_c, + avmMini_last + }; + }; + RefVector get_to_be_shifted() + { + return { memTrace_m_val, memTrace_m_rw, memTrace_m_addr, avmMini_ret_ptr, avmMini_pc }; }; - RefVector get_to_be_shifted() { return { memTrace_m_rw, memTrace_m_addr, memTrace_m_val }; }; RefVector get_shifted() { - return { memTrace_m_rw_shift, memTrace_m_addr_shift, memTrace_m_val_shift }; + return { memTrace_m_val_shift, + memTrace_m_rw_shift, + memTrace_m_addr_shift, + avmMini_ret_ptr_shift, + avmMini_pc_shift }; }; }; @@ -296,6 +302,10 @@ class AvmMiniFlavor { Base::memTrace_m_val = "MEMTRACE_M_VAL"; Base::memTrace_m_lastAccess = "MEMTRACE_M_LASTACCESS"; Base::memTrace_m_rw = "MEMTRACE_M_RW"; + Base::avmMini_pc = "AVMMINI_PC"; + Base::avmMini_ret_ptr = "AVMMINI_RET_PTR"; + Base::avmMini_sel_jump = "AVMMINI_SEL_JUMP"; + Base::avmMini_sel_ret = "AVMMINI_SEL_RET"; Base::avmMini_sel_op_add = "AVMMINI_SEL_OP_ADD"; Base::avmMini_sel_op_sub = "AVMMINI_SEL_OP_SUB"; Base::avmMini_sel_op_mul = "AVMMINI_SEL_OP_MUL"; @@ -340,6 +350,10 @@ class AvmMiniFlavor { Commitment memTrace_m_val; Commitment memTrace_m_lastAccess; Commitment memTrace_m_rw; + Commitment avmMini_pc; + Commitment avmMini_ret_ptr; + Commitment avmMini_sel_jump; + Commitment avmMini_sel_ret; Commitment avmMini_sel_op_add; Commitment avmMini_sel_op_sub; Commitment avmMini_sel_op_mul; @@ -384,6 +398,10 @@ class AvmMiniFlavor { memTrace_m_val = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); memTrace_m_lastAccess = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); memTrace_m_rw = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); + avmMini_pc = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); + avmMini_ret_ptr = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); + avmMini_sel_jump = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); + avmMini_sel_ret = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_op_add = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_op_sub = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_op_mul = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); @@ -432,6 +450,10 @@ class AvmMiniFlavor { serialize_to_buffer(memTrace_m_val, Transcript::proof_data); serialize_to_buffer(memTrace_m_lastAccess, Transcript::proof_data); serialize_to_buffer(memTrace_m_rw, Transcript::proof_data); + serialize_to_buffer(avmMini_pc, Transcript::proof_data); + serialize_to_buffer(avmMini_ret_ptr, Transcript::proof_data); + serialize_to_buffer(avmMini_sel_jump, Transcript::proof_data); + serialize_to_buffer(avmMini_sel_ret, Transcript::proof_data); serialize_to_buffer(avmMini_sel_op_add, Transcript::proof_data); serialize_to_buffer(avmMini_sel_op_sub, Transcript::proof_data); serialize_to_buffer(avmMini_sel_op_mul, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp index 8470c2f7b5c3..5021267c2d2e 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp @@ -27,6 +27,10 @@ template struct AvmMiniFullRow { FF memTrace_m_val{}; FF memTrace_m_lastAccess{}; FF memTrace_m_rw{}; + FF avmMini_pc{}; + FF avmMini_ret_ptr{}; + FF avmMini_sel_jump{}; + FF avmMini_sel_ret{}; FF avmMini_sel_op_add{}; FF avmMini_sel_op_sub{}; FF avmMini_sel_op_mul{}; @@ -46,9 +50,11 @@ template struct AvmMiniFullRow { FF avmMini_mem_idx_b{}; FF avmMini_mem_idx_c{}; FF avmMini_last{}; + FF memTrace_m_val_shift{}; FF memTrace_m_rw_shift{}; FF memTrace_m_addr_shift{}; - FF memTrace_m_val_shift{}; + FF avmMini_ret_ptr_shift{}; + FF avmMini_pc_shift{}; }; class AvmMiniCircuitBuilder { @@ -61,8 +67,8 @@ class AvmMiniCircuitBuilder { using Polynomial = Flavor::Polynomial; using AllPolynomials = Flavor::AllPolynomials; - static constexpr size_t num_fixed_columns = 30; - static constexpr size_t num_polys = 27; + static constexpr size_t num_fixed_columns = 36; + static constexpr size_t num_polys = 31; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -86,6 +92,10 @@ class AvmMiniCircuitBuilder { polys.memTrace_m_val[i] = rows[i].memTrace_m_val; polys.memTrace_m_lastAccess[i] = rows[i].memTrace_m_lastAccess; polys.memTrace_m_rw[i] = rows[i].memTrace_m_rw; + polys.avmMini_pc[i] = rows[i].avmMini_pc; + polys.avmMini_ret_ptr[i] = rows[i].avmMini_ret_ptr; + polys.avmMini_sel_jump[i] = rows[i].avmMini_sel_jump; + polys.avmMini_sel_ret[i] = rows[i].avmMini_sel_ret; polys.avmMini_sel_op_add[i] = rows[i].avmMini_sel_op_add; polys.avmMini_sel_op_sub[i] = rows[i].avmMini_sel_op_sub; polys.avmMini_sel_op_mul[i] = rows[i].avmMini_sel_op_mul; @@ -107,9 +117,11 @@ class AvmMiniCircuitBuilder { polys.avmMini_last[i] = rows[i].avmMini_last; } + polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); - polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); + polys.avmMini_ret_ptr_shift = Polynomial(polys.avmMini_ret_ptr.shifted()); + polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); return polys; } @@ -120,7 +132,8 @@ class AvmMiniCircuitBuilder { auto polys = compute_polynomials(); const size_t num_rows = polys.get_polynomial_size(); - const auto evaluate_relation = [&](const std::string& relation_name) { + const auto evaluate_relation = [&](const std::string& relation_name, + std::string (*debug_label)(int)) { typename Relation::SumcheckArrayOfValuesOverSubrelations result; for (auto& r : result) { r = 0; @@ -133,8 +146,9 @@ class AvmMiniCircuitBuilder { bool x = true; for (size_t j = 0; j < NUM_SUBRELATIONS; ++j) { if (result[j] != 0) { + std::string row_name = debug_label(static_cast(j)); throw_or_abort( - format("Relation ", relation_name, ", subrelation index ", j, " failed at row ", i)); + format("Relation ", relation_name, ", subrelation index ", row_name, " failed at row ", i)); x = false; } } @@ -145,10 +159,12 @@ class AvmMiniCircuitBuilder { return true; }; - if (!evaluate_relation.template operator()>("mem_trace")) { + if (!evaluate_relation.template operator()>( + "mem_trace", AvmMini_vm::get_relation_label_mem_trace)) { return false; } - if (!evaluate_relation.template operator()>("avm_mini")) { + if (!evaluate_relation.template operator()>("avm_mini", + AvmMini_vm::get_relation_label_avm_mini)) { return false; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp index bb4a3242ae0c..9b5b63d12830 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp @@ -7,29 +7,42 @@ namespace proof_system::AvmMini_vm { template struct Avm_miniRow { - FF avmMini_sel_op_div{}; - FF avmMini_ia{}; FF avmMini_rwa{}; - FF avmMini_sel_op_sub{}; + FF avmMini_ret_ptr_shift{}; + FF avmMini_pc{}; + FF avmMini_sel_jump{}; FF avmMini_rwb{}; - FF avmMini_ic{}; FF avmMini_inv{}; - FF avmMini_sel_op_add{}; - FF avmMini_op_err{}; + FF avmMini_sel_op_sub{}; + FF avmMini_ia{}; + FF avmMini_ib{}; + FF avmMini_pc_shift{}; + FF avmMini_mem_op_a{}; + FF avmMini_sel_op_div{}; FF avmMini_sel_op_mul{}; + FF avmMini_mem_idx_a{}; FF avmMini_rwc{}; - FF avmMini_ib{}; + FF avmMini_sel_op_add{}; FF avmMini_mem_op_b{}; - FF avmMini_mem_op_a{}; + FF avmMini_op_err{}; + FF avmMini_ic{}; + FF avmMini_sel_ret{}; FF avmMini_mem_op_c{}; + FF avmMini_ret_ptr{}; }; +inline std::string get_relation_label_avm_mini(int index) +{ + switch (index) {} + return std::to_string(index); +} + template class avm_miniImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, }; template @@ -183,6 +196,95 @@ template class avm_miniImpl { tmp *= scaling_factor; std::get<17>(evals) += tmp; } + // Contribution 18 + { + AvmMini_DECLARE_VIEWS(18); + + auto tmp = (avmMini_sel_jump * (avmMini_ret_ptr_shift - (avmMini_ret_ptr + FF(1)))); + tmp *= scaling_factor; + std::get<18>(evals) += tmp; + } + // Contribution 19 + { + AvmMini_DECLARE_VIEWS(19); + + auto tmp = (avmMini_sel_jump * (avmMini_ret_ptr - avmMini_mem_idx_a)); + tmp *= scaling_factor; + std::get<19>(evals) += tmp; + } + // Contribution 20 + { + AvmMini_DECLARE_VIEWS(20); + + auto tmp = (avmMini_sel_jump * (avmMini_rwa - FF(1))); + tmp *= scaling_factor; + std::get<20>(evals) += tmp; + } + // Contribution 21 + { + AvmMini_DECLARE_VIEWS(21); + + auto tmp = (avmMini_sel_jump * (avmMini_mem_op_a - FF(1))); + tmp *= scaling_factor; + std::get<21>(evals) += tmp; + } + // Contribution 22 + { + AvmMini_DECLARE_VIEWS(22); + + auto tmp = (avmMini_sel_jump * (avmMini_pc_shift - avmMini_ia)); + tmp *= scaling_factor; + std::get<22>(evals) += tmp; + } + // Contribution 23 + { + AvmMini_DECLARE_VIEWS(23); + + auto tmp = (avmMini_sel_ret * (avmMini_ret_ptr_shift - (avmMini_ret_ptr - FF(1)))); + tmp *= scaling_factor; + std::get<23>(evals) += tmp; + } + // Contribution 24 + { + AvmMini_DECLARE_VIEWS(24); + + auto tmp = (avmMini_sel_ret * (avmMini_ret_ptr - avmMini_mem_idx_a)); + tmp *= scaling_factor; + std::get<24>(evals) += tmp; + } + // Contribution 25 + { + AvmMini_DECLARE_VIEWS(25); + + auto tmp = (avmMini_sel_ret * (avmMini_pc_shift - avmMini_ia)); + tmp *= scaling_factor; + std::get<25>(evals) += tmp; + } + // Contribution 26 + { + AvmMini_DECLARE_VIEWS(26); + + auto tmp = (avmMini_sel_ret * avmMini_rwa); + tmp *= scaling_factor; + std::get<26>(evals) += tmp; + } + // Contribution 27 + { + AvmMini_DECLARE_VIEWS(27); + + auto tmp = (avmMini_sel_ret * (avmMini_mem_op_a - FF(1))); + tmp *= scaling_factor; + std::get<27>(evals) += tmp; + } + // Contribution 28 + { + AvmMini_DECLARE_VIEWS(28); + + auto tmp = (((-avmMini_sel_jump + FF(1)) * (-avmMini_sel_ret + FF(1))) * + (avmMini_pc_shift - (avmMini_pc + FF(1)))); + tmp *= scaling_factor; + std::get<28>(evals) += tmp; + } } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp index e2abc409ea4b..5beb7d49b548 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp @@ -10,6 +10,10 @@ [[maybe_unused]] auto memTrace_m_val = View(new_term.memTrace_m_val); \ [[maybe_unused]] auto memTrace_m_lastAccess = View(new_term.memTrace_m_lastAccess); \ [[maybe_unused]] auto memTrace_m_rw = View(new_term.memTrace_m_rw); \ + [[maybe_unused]] auto avmMini_pc = View(new_term.avmMini_pc); \ + [[maybe_unused]] auto avmMini_ret_ptr = View(new_term.avmMini_ret_ptr); \ + [[maybe_unused]] auto avmMini_sel_jump = View(new_term.avmMini_sel_jump); \ + [[maybe_unused]] auto avmMini_sel_ret = View(new_term.avmMini_sel_ret); \ [[maybe_unused]] auto avmMini_sel_op_add = View(new_term.avmMini_sel_op_add); \ [[maybe_unused]] auto avmMini_sel_op_sub = View(new_term.avmMini_sel_op_sub); \ [[maybe_unused]] auto avmMini_sel_op_mul = View(new_term.avmMini_sel_op_mul); \ @@ -29,6 +33,8 @@ [[maybe_unused]] auto avmMini_mem_idx_b = View(new_term.avmMini_mem_idx_b); \ [[maybe_unused]] auto avmMini_mem_idx_c = View(new_term.avmMini_mem_idx_c); \ [[maybe_unused]] auto avmMini_last = View(new_term.avmMini_last); \ + [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ - [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); + [[maybe_unused]] auto avmMini_ret_ptr_shift = View(new_term.avmMini_ret_ptr_shift); \ + [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp index 7bfb1b223cda..5282fb62148b 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp @@ -7,17 +7,23 @@ namespace proof_system::AvmMini_vm { template struct Mem_traceRow { - FF memTrace_m_rw_shift{}; - FF memTrace_m_addr_shift{}; + FF memTrace_m_val_shift{}; FF memTrace_m_val{}; + FF memTrace_m_lastAccess{}; + FF memTrace_m_rw_shift{}; FF memTrace_m_addr{}; FF memTrace_m_rw{}; + FF memTrace_m_addr_shift{}; FF avmMini_first{}; - FF memTrace_m_lastAccess{}; FF avmMini_last{}; - FF memTrace_m_val_shift{}; }; +inline std::string get_relation_label_mem_trace(int index) +{ + switch (index) {} + return std::to_string(index); +} + template class mem_traceImpl { public: using FF = FF_; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp index d07684fc3eca..91f5a44b4f86 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp @@ -25,6 +25,10 @@ void AvmMiniComposer::compute_witness(CircuitConstructor& circuit) proving_key->memTrace_m_val = polynomials.memTrace_m_val; proving_key->memTrace_m_lastAccess = polynomials.memTrace_m_lastAccess; proving_key->memTrace_m_rw = polynomials.memTrace_m_rw; + proving_key->avmMini_pc = polynomials.avmMini_pc; + proving_key->avmMini_ret_ptr = polynomials.avmMini_ret_ptr; + proving_key->avmMini_sel_jump = polynomials.avmMini_sel_jump; + proving_key->avmMini_sel_ret = polynomials.avmMini_sel_ret; proving_key->avmMini_sel_op_add = polynomials.avmMini_sel_op_add; proving_key->avmMini_sel_op_sub = polynomials.avmMini_sel_op_sub; proving_key->avmMini_sel_op_mul = polynomials.avmMini_sel_op_mul; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp index 86a691495c0f..11f1ce8c9c34 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp @@ -38,6 +38,10 @@ AvmMiniProver::AvmMiniProver(std::shared_ptr input_key, prover_polynomials.memTrace_m_val = key->memTrace_m_val; prover_polynomials.memTrace_m_lastAccess = key->memTrace_m_lastAccess; prover_polynomials.memTrace_m_rw = key->memTrace_m_rw; + prover_polynomials.avmMini_pc = key->avmMini_pc; + prover_polynomials.avmMini_ret_ptr = key->avmMini_ret_ptr; + prover_polynomials.avmMini_sel_jump = key->avmMini_sel_jump; + prover_polynomials.avmMini_sel_ret = key->avmMini_sel_ret; prover_polynomials.avmMini_sel_op_add = key->avmMini_sel_op_add; prover_polynomials.avmMini_sel_op_sub = key->avmMini_sel_op_sub; prover_polynomials.avmMini_sel_op_mul = key->avmMini_sel_op_mul; @@ -58,14 +62,20 @@ AvmMiniProver::AvmMiniProver(std::shared_ptr input_key, prover_polynomials.avmMini_mem_idx_c = key->avmMini_mem_idx_c; prover_polynomials.avmMini_last = key->avmMini_last; + prover_polynomials.memTrace_m_val = key->memTrace_m_val; + prover_polynomials.memTrace_m_val_shift = key->memTrace_m_val.shifted(); + prover_polynomials.memTrace_m_rw = key->memTrace_m_rw; prover_polynomials.memTrace_m_rw_shift = key->memTrace_m_rw.shifted(); prover_polynomials.memTrace_m_addr = key->memTrace_m_addr; prover_polynomials.memTrace_m_addr_shift = key->memTrace_m_addr.shifted(); - prover_polynomials.memTrace_m_val = key->memTrace_m_val; - prover_polynomials.memTrace_m_val_shift = key->memTrace_m_val.shifted(); + prover_polynomials.avmMini_ret_ptr = key->avmMini_ret_ptr; + prover_polynomials.avmMini_ret_ptr_shift = key->avmMini_ret_ptr.shifted(); + + prover_polynomials.avmMini_pc = key->avmMini_pc; + prover_polynomials.avmMini_pc_shift = key->avmMini_pc.shifted(); // prover_polynomials.lookup_inverses = key->lookup_inverses; // key->z_perm = Polynomial(key->circuit_size); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp index 4014eec57bb7..1365b676b210 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp @@ -64,6 +64,13 @@ bool AvmMiniVerifier::verify_proof(const plonk::proof& proof) commitments.memTrace_m_lastAccess = transcript->template receive_from_prover(commitment_labels.memTrace_m_lastAccess); commitments.memTrace_m_rw = transcript->template receive_from_prover(commitment_labels.memTrace_m_rw); + commitments.avmMini_pc = transcript->template receive_from_prover(commitment_labels.avmMini_pc); + commitments.avmMini_ret_ptr = + transcript->template receive_from_prover(commitment_labels.avmMini_ret_ptr); + commitments.avmMini_sel_jump = + transcript->template receive_from_prover(commitment_labels.avmMini_sel_jump); + commitments.avmMini_sel_ret = + transcript->template receive_from_prover(commitment_labels.avmMini_sel_ret); commitments.avmMini_sel_op_add = transcript->template receive_from_prover(commitment_labels.avmMini_sel_op_add); commitments.avmMini_sel_op_sub = From 77a542509efeb43fb660188b9b416457c6a94d7d Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 15 Dec 2023 17:42:44 +0000 Subject: [PATCH 02/10] fix: only increment pc on opcode --- barretenberg/cpp/pil/avm/avm_mini.pil | 33 ++-- .../flavor/generated/AvmMini_flavor.hpp | 141 ++++++++++++------ .../circuit_builder/AvmMini_helper.cpp | 68 +++++---- .../circuit_builder/AvmMini_trace.cpp | 62 ++++++++ .../circuit_builder/AvmMini_trace.hpp | 15 ++ .../generated/AvmMini_circuit_builder.hpp | 20 +-- .../relations/generated/AvmMini/avm_mini.hpp | 64 ++++---- .../generated/AvmMini/declare_views.hpp | 12 +- .../relations/generated/AvmMini/mem_trace.hpp | 12 +- .../vm/generated/AvmMini_composer.cpp | 6 +- .../vm/generated/AvmMini_prover.cpp | 18 +-- .../vm/generated/AvmMini_verifier.cpp | 12 +- .../vm/tests/AvmMini_arithmetic.test.cpp | 5 + 13 files changed, 305 insertions(+), 163 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index e2bbc8041136..5d9b50cba1d8 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -12,10 +12,10 @@ namespace avmMini(256); // Program counter pol commit pc; // Return Pointer - pol commit ret_ptr; + pol commit internal_return_ptr; - pol commit sel_jump; - pol commit sel_ret; + pol commit sel_internal_call; + pol commit sel_internal_return; //===== TABLE SUBOP-TR ======================================================== @@ -121,25 +121,26 @@ namespace avmMini(256); // Drawback is the need to paralllelize the latter. - //===== JUMP_RETURN ======================================================== + //===== CALL_RETURN ======================================================== // The program counter in the next row should be equal to the value loaded from the ia register // This implies that a load from memory must occur at the same time // Imply that we must load the jump selector into mema - sel_jump * (ret_ptr' - (ret_ptr + 1)) = 0; // we increment our jump selector - sel_jump * (ret_ptr - mem_idx_a) = 0; - sel_jump * (rwa - 1) = 0; // it must be a write - sel_jump * (mem_op_a - 1) = 0; - sel_jump * (pc' - ia) = 0; + sel_internal_call * ( internal_return_ptr' - ( internal_return_ptr + 1)) = 0; // we increment our jump selector + sel_internal_call * ( internal_return_ptr - mem_idx_a) = 0; + sel_internal_call * (rwa - 1) = 0; // it must be a write + sel_internal_call * (mem_op_a - 1) = 0; + sel_internal_call * (pc' - ia) = 0; - // We must load the memory pointer to be the ret_ptr - sel_ret * (ret_ptr' - (ret_ptr - 1)) = 0; // We decrement out jump selector - sel_ret * (ret_ptr - mem_idx_a) = 0; - sel_ret * (pc' - ia) = 0; - sel_ret * rwa = 0; - sel_ret * (mem_op_a - 1) = 0; + // We must load the memory pointer to be the internal_return_ptr + sel_internal_return * ( internal_return_ptr' - ( internal_return_ptr - 1)) = 0; // We decrement out jump selector + sel_internal_return * ( internal_return_ptr - mem_idx_a) = 0; + sel_internal_return * (pc' - ia) = 0; + sel_internal_return * rwa = 0; + sel_internal_return * (mem_op_a - 1) = 0; // Program counter must increment if not jumping or returning - (1 - sel_jump) * (1- sel_ret) * (pc' - (pc + 1)) = 0; + #[pc_increment] + (1-first) * (sel_internal_call + sel_internal_return + sel_op_add + sel_op_sub + sel_op_div + sel_op_mul) * (pc' - (pc + 1)) = 0; // TODO: we want to set an initial number for the reserved memory of the jump pointer diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp index add1c64ce644..f4384833874a 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp @@ -83,9 +83,9 @@ class AvmMiniFlavor { memTrace_m_lastAccess, memTrace_m_rw, avmMini_pc, - avmMini_ret_ptr, - avmMini_sel_jump, - avmMini_sel_ret, + avmMini_internal_return_ptr, + avmMini_sel_internal_call, + avmMini_sel_internal_return, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -108,14 +108,35 @@ class AvmMiniFlavor { RefVector get_wires() { - return { - memTrace_m_clk, memTrace_m_sub_clk, memTrace_m_addr, memTrace_m_val, memTrace_m_lastAccess, - memTrace_m_rw, avmMini_pc, avmMini_ret_ptr, avmMini_sel_jump, avmMini_sel_ret, - avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, avmMini_sel_op_div, avmMini_op_err, - avmMini_inv, avmMini_ia, avmMini_ib, avmMini_ic, avmMini_mem_op_a, - avmMini_mem_op_b, avmMini_mem_op_c, avmMini_rwa, avmMini_rwb, avmMini_rwc, - avmMini_mem_idx_a, avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last - }; + return { memTrace_m_clk, + memTrace_m_sub_clk, + memTrace_m_addr, + memTrace_m_val, + memTrace_m_lastAccess, + memTrace_m_rw, + avmMini_pc, + avmMini_internal_return_ptr, + avmMini_sel_internal_call, + avmMini_sel_internal_return, + avmMini_sel_op_add, + avmMini_sel_op_sub, + avmMini_sel_op_mul, + avmMini_sel_op_div, + avmMini_op_err, + avmMini_inv, + avmMini_ia, + avmMini_ib, + avmMini_ic, + avmMini_mem_op_a, + avmMini_mem_op_b, + avmMini_mem_op_c, + avmMini_rwa, + avmMini_rwb, + avmMini_rwc, + avmMini_mem_idx_a, + avmMini_mem_idx_b, + avmMini_mem_idx_c, + avmMini_last }; }; RefVector get_sorted_polynomials() { return {}; }; }; @@ -132,9 +153,9 @@ class AvmMiniFlavor { memTrace_m_lastAccess, memTrace_m_rw, avmMini_pc, - avmMini_ret_ptr, - avmMini_sel_jump, - avmMini_sel_ret, + avmMini_internal_return_ptr, + avmMini_sel_internal_call, + avmMini_sel_internal_return, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -154,11 +175,11 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, + memTrace_m_addr_shift, memTrace_m_val_shift, memTrace_m_rw_shift, - memTrace_m_addr_shift, - avmMini_ret_ptr_shift, - avmMini_pc_shift) + avmMini_pc_shift, + avmMini_internal_return_ptr_shift) RefVector get_wires() { @@ -171,9 +192,9 @@ class AvmMiniFlavor { memTrace_m_lastAccess, memTrace_m_rw, avmMini_pc, - avmMini_ret_ptr, - avmMini_sel_jump, - avmMini_sel_ret, + avmMini_internal_return_ptr, + avmMini_sel_internal_call, + avmMini_sel_internal_return, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -193,35 +214,57 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, + memTrace_m_addr_shift, memTrace_m_val_shift, memTrace_m_rw_shift, - memTrace_m_addr_shift, - avmMini_ret_ptr_shift, - avmMini_pc_shift }; + avmMini_pc_shift, + avmMini_internal_return_ptr_shift }; }; RefVector get_unshifted() { - return { - avmMini_clk, avmMini_first, memTrace_m_clk, memTrace_m_sub_clk, memTrace_m_addr, - memTrace_m_val, memTrace_m_lastAccess, memTrace_m_rw, avmMini_pc, avmMini_ret_ptr, - avmMini_sel_jump, avmMini_sel_ret, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, - avmMini_sel_op_div, avmMini_op_err, avmMini_inv, avmMini_ia, avmMini_ib, - avmMini_ic, avmMini_mem_op_a, avmMini_mem_op_b, avmMini_mem_op_c, avmMini_rwa, - avmMini_rwb, avmMini_rwc, avmMini_mem_idx_a, avmMini_mem_idx_b, avmMini_mem_idx_c, - avmMini_last - }; + return { avmMini_clk, + avmMini_first, + memTrace_m_clk, + memTrace_m_sub_clk, + memTrace_m_addr, + memTrace_m_val, + memTrace_m_lastAccess, + memTrace_m_rw, + avmMini_pc, + avmMini_internal_return_ptr, + avmMini_sel_internal_call, + avmMini_sel_internal_return, + avmMini_sel_op_add, + avmMini_sel_op_sub, + avmMini_sel_op_mul, + avmMini_sel_op_div, + avmMini_op_err, + avmMini_inv, + avmMini_ia, + avmMini_ib, + avmMini_ic, + avmMini_mem_op_a, + avmMini_mem_op_b, + avmMini_mem_op_c, + avmMini_rwa, + avmMini_rwb, + avmMini_rwc, + avmMini_mem_idx_a, + avmMini_mem_idx_b, + avmMini_mem_idx_c, + avmMini_last }; }; RefVector get_to_be_shifted() { - return { memTrace_m_val, memTrace_m_rw, memTrace_m_addr, avmMini_ret_ptr, avmMini_pc }; + return { memTrace_m_addr, memTrace_m_val, memTrace_m_rw, avmMini_pc, avmMini_internal_return_ptr }; }; RefVector get_shifted() { - return { memTrace_m_val_shift, + return { memTrace_m_addr_shift, + memTrace_m_val_shift, memTrace_m_rw_shift, - memTrace_m_addr_shift, - avmMini_ret_ptr_shift, - avmMini_pc_shift }; + avmMini_pc_shift, + avmMini_internal_return_ptr_shift }; }; }; @@ -303,9 +346,9 @@ class AvmMiniFlavor { Base::memTrace_m_lastAccess = "MEMTRACE_M_LASTACCESS"; Base::memTrace_m_rw = "MEMTRACE_M_RW"; Base::avmMini_pc = "AVMMINI_PC"; - Base::avmMini_ret_ptr = "AVMMINI_RET_PTR"; - Base::avmMini_sel_jump = "AVMMINI_SEL_JUMP"; - Base::avmMini_sel_ret = "AVMMINI_SEL_RET"; + Base::avmMini_internal_return_ptr = "AVMMINI_INTERNAL_RETURN_PTR"; + Base::avmMini_sel_internal_call = "AVMMINI_SEL_INTERNAL_CALL"; + Base::avmMini_sel_internal_return = "AVMMINI_SEL_INTERNAL_RETURN"; Base::avmMini_sel_op_add = "AVMMINI_SEL_OP_ADD"; Base::avmMini_sel_op_sub = "AVMMINI_SEL_OP_SUB"; Base::avmMini_sel_op_mul = "AVMMINI_SEL_OP_MUL"; @@ -351,9 +394,9 @@ class AvmMiniFlavor { Commitment memTrace_m_lastAccess; Commitment memTrace_m_rw; Commitment avmMini_pc; - Commitment avmMini_ret_ptr; - Commitment avmMini_sel_jump; - Commitment avmMini_sel_ret; + Commitment avmMini_internal_return_ptr; + Commitment avmMini_sel_internal_call; + Commitment avmMini_sel_internal_return; Commitment avmMini_sel_op_add; Commitment avmMini_sel_op_sub; Commitment avmMini_sel_op_mul; @@ -399,9 +442,9 @@ class AvmMiniFlavor { memTrace_m_lastAccess = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); memTrace_m_rw = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_pc = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); - avmMini_ret_ptr = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); - avmMini_sel_jump = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); - avmMini_sel_ret = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); + avmMini_internal_return_ptr = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); + avmMini_sel_internal_call = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); + avmMini_sel_internal_return = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_op_add = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_op_sub = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_op_mul = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); @@ -451,9 +494,9 @@ class AvmMiniFlavor { serialize_to_buffer(memTrace_m_lastAccess, Transcript::proof_data); serialize_to_buffer(memTrace_m_rw, Transcript::proof_data); serialize_to_buffer(avmMini_pc, Transcript::proof_data); - serialize_to_buffer(avmMini_ret_ptr, Transcript::proof_data); - serialize_to_buffer(avmMini_sel_jump, Transcript::proof_data); - serialize_to_buffer(avmMini_sel_ret, Transcript::proof_data); + serialize_to_buffer(avmMini_internal_return_ptr, Transcript::proof_data); + serialize_to_buffer(avmMini_sel_internal_call, Transcript::proof_data); + serialize_to_buffer(avmMini_sel_internal_return, Transcript::proof_data); serialize_to_buffer(avmMini_sel_op_add, Transcript::proof_data); serialize_to_buffer(avmMini_sel_op_sub, Transcript::proof_data); serialize_to_buffer(avmMini_sel_op_mul, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp index 401ad709c435..be282d9c1a6d 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp @@ -19,38 +19,44 @@ void log_avmMini_trace(std::vector const& trace, size_t beg, size_t end) info("Built circuit with ", trace.size(), " rows"); for (size_t i = beg; i < end; i++) { - info("================================================================================"); + info("====================================================================================="); info("== ROW ", i); - info("================================================================================"); - - info("m_addr: ", trace.at(i).memTrace_m_addr); - info("m_clk: ", trace.at(i).memTrace_m_clk); - info("m_sub_clk: ", trace.at(i).memTrace_m_sub_clk); - info("m_val: ", trace.at(i).memTrace_m_val); - info("m_lastAccess: ", trace.at(i).memTrace_m_lastAccess); - info("m_rw: ", trace.at(i).memTrace_m_rw); - info("m_val_shift: ", trace.at(i).memTrace_m_val_shift); - info("first: ", trace.at(i).avmMini_first); - info("last: ", trace.at(i).avmMini_last); - - info("=======MEM_OP_A================================================================="); - info("clk: ", trace.at(i).avmMini_clk); - info("mem_op_a: ", trace.at(i).avmMini_mem_op_a); - info("mem_idx_a: ", trace.at(i).avmMini_mem_idx_a); - info("ia: ", trace.at(i).avmMini_ia); - info("rwa: ", trace.at(i).avmMini_rwa); - - info("=======MEM_OP_B================================================================="); - info("mem_op_b: ", trace.at(i).avmMini_mem_op_b); - info("mem_idx_b: ", trace.at(i).avmMini_mem_idx_b); - info("ib: ", trace.at(i).avmMini_ib); - info("rwb: ", trace.at(i).avmMini_rwb); - - info("=======MEM_OP_C================================================================="); - info("mem_op_c: ", trace.at(i).avmMini_mem_op_c); - info("mem_idx_c: ", trace.at(i).avmMini_mem_idx_c); - info("ic: ", trace.at(i).avmMini_ic); - info("rwc: ", trace.at(i).avmMini_rwc); + info("====================================================================================="); + + info("m_addr: ", trace.at(i).memTrace_m_addr); + info("m_clk: ", trace.at(i).memTrace_m_clk); + info("m_sub_clk: ", trace.at(i).memTrace_m_sub_clk); + info("m_val: ", trace.at(i).memTrace_m_val); + info("m_lastAccess: ", trace.at(i).memTrace_m_lastAccess); + info("m_rw: ", trace.at(i).memTrace_m_rw); + info("m_val_shift: ", trace.at(i).memTrace_m_val_shift); + info("first: ", trace.at(i).avmMini_first); + info("last: ", trace.at(i).avmMini_last); + + info("=======CONTROL_FLOW==================================================================="); + info("pc: ", trace.at(i).avmMini_pc); + info("internal_call: ", trace.at(i).avmMini_sel_internal_call); + info("internal_return: ", trace.at(i).avmMini_sel_internal_return); + info("internal_return_ptr:", trace.at(i).avmMini_internal_return_ptr); + + info("=======MEM_OP_A======================================================================"); + info("clk: ", trace.at(i).avmMini_clk); + info("mem_op_a: ", trace.at(i).avmMini_mem_op_a); + info("mem_idx_a: ", trace.at(i).avmMini_mem_idx_a); + info("ia: ", trace.at(i).avmMini_ia); + info("rwa: ", trace.at(i).avmMini_rwa); + + info("=======MEM_OP_B======================================================================"); + info("mem_op_b: ", trace.at(i).avmMini_mem_op_b); + info("mem_idx_b: ", trace.at(i).avmMini_mem_idx_b); + info("ib: ", trace.at(i).avmMini_ib); + info("rwb: ", trace.at(i).avmMini_rwb); + + info("=======MEM_OP_C======================================================================"); + info("mem_op_c: ", trace.at(i).avmMini_mem_op_c); + info("mem_idx_c: ", trace.at(i).avmMini_mem_idx_c); + info("ic: ", trace.at(i).avmMini_ic); + info("rwc: ", trace.at(i).avmMini_rwc); info("\n"); } } diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index 8562a72c41cf..b1ebdfcfc1b3 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -185,6 +185,7 @@ void AvmMiniTraceBuilder::add(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf mainTrace.push_back(Row{ .avmMini_clk = clk, + .avmMini_pc = FF(pc++), .avmMini_sel_op_add = FF(1), .avmMini_ia = a, .avmMini_ib = b, @@ -227,6 +228,7 @@ void AvmMiniTraceBuilder::sub(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf mainTrace.push_back(Row{ .avmMini_clk = clk, + .avmMini_pc = FF(pc++), .avmMini_sel_op_sub = FF(1), .avmMini_ia = a, .avmMini_ib = b, @@ -269,6 +271,7 @@ void AvmMiniTraceBuilder::mul(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf mainTrace.push_back(Row{ .avmMini_clk = clk, + .avmMini_pc = FF(pc++), .avmMini_sel_op_mul = FF(1), .avmMini_ia = a, .avmMini_ib = b, @@ -325,6 +328,7 @@ void AvmMiniTraceBuilder::div(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf mainTrace.push_back(Row{ .avmMini_clk = clk, + .avmMini_pc = FF(pc++), .avmMini_sel_op_div = FF(1), .avmMini_op_err = error, .avmMini_inv = inv, @@ -416,6 +420,7 @@ void AvmMiniTraceBuilder::callDataCopy(uint32_t cdOffset, mainTrace.push_back(Row{ .avmMini_clk = clk, + .avmMini_pc = FF(pc++), .avmMini_ia = ia, .avmMini_ib = ib, .avmMini_ic = ic, @@ -502,6 +507,7 @@ std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSi mainTrace.push_back(Row{ .avmMini_clk = clk, + .avmMini_pc = FF(pc++), .avmMini_ia = ia, .avmMini_ib = ib, .avmMini_ic = ic, @@ -522,6 +528,62 @@ std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSi return returnMem; } +void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) +{ + auto clk = mainTrace.size(); + + // TODO: make sure this is initialized + internal_call_stack.push(pc); + FF a = ffMemory.at(internal_return_ptr); + + // We want to write the current pc to the memory location pointed by + storeAInMemTrace(internal_return_ptr, FF(pc)); + + mainTrace.push_back(Row{ + .avmMini_clk = clk, + .avmMini_pc = FF(pc), + .avmMini_internal_return_ptr = FF(internal_return_ptr), + .avmMini_ia = a, + .avmMini_mem_op_a = FF(1), + .avmMini_rwa = FF(1), + .avmMini_mem_idx_a = FF(internal_return_ptr), + }); + + // We want the next row to be the one pointed by jmpDest + pc = jmpDest; + internal_return_ptr++; +} + +void AvmMiniTraceBuilder::internal_return() +{ + auto clk = mainTrace.size(); + + // TODO: make sure this is initialized + FF a = ffMemory.at(internal_return_ptr); + + // We want to write the current pc to the memory location pointed by + storeAInMemTrace(internal_return_ptr, FF(pc)); + + mainTrace.push_back(Row{ + .avmMini_clk = clk, + .avmMini_pc = pc, + .avmMini_ia = a, + .avmMini_mem_op_a = FF(1), + .avmMini_rwa = FF(0), + .avmMini_mem_idx_a = FF(internal_return_ptr), + }); + + // We want the next row to be the one pointed by jmpDest + // TODO: is this type casting safe + + // The next pc should be from the top of the internal call stack + pc = internal_call_stack.top(); + internal_call_stack.pop(); + + // The internal call stack pointer should be decremented + internal_return_ptr--; +} + /** * @brief Helper to initialize ffMemory. (Testing purpose mostly.) * diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp index a4621c22e199..c3609c1abf83 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp @@ -1,5 +1,7 @@ #pragma once +#include + #include "barretenberg/common/throw_or_abort.hpp" #include "barretenberg/ecc/curves/bn254/fr.hpp" #include "barretenberg/proof_system/circuit_builder/circuit_builder_base.hpp" @@ -25,6 +27,7 @@ class AvmMiniTraceBuilder { // Number of rows static const size_t N = 256; static const size_t MEM_SIZE = 1024; + static const size_t CALLSTACK_OFFSET = 1024; // TODO is this the vibe static const uint32_t SUB_CLK_LOAD_A = 0; static const uint32_t SUB_CLK_LOAD_B = 1; @@ -53,6 +56,13 @@ class AvmMiniTraceBuilder { // Division over finite field with direct memory access. void div(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset); + // Jump to a given program counter. + // TODO: this program counter MUST be an operand to the OPCODE. + void internal_call(uint32_t jmpDest); + + // Return from a jump. + void internal_return(); + // CALLDATACOPY opcode with direct memory access, i.e., // M[dstOffset:dstOffset+copySize] = calldata[cdOffset:cdOffset+copySize] void callDataCopy(uint32_t cdOffset, uint32_t copySize, uint32_t dstOffset, std::vector const& callDataMem); @@ -66,6 +76,7 @@ class AvmMiniTraceBuilder { uint32_t m_clk; uint32_t m_sub_clk; uint32_t m_addr; + FF m_val; bool m_rw; }; @@ -75,6 +86,10 @@ class AvmMiniTraceBuilder { std::array ffMemory{}; // Memory table for finite field elements // Used for simulation of memory table + uint32_t pc = 0; + uint32_t internal_return_ptr = CALLSTACK_OFFSET; + std::stack internal_call_stack; // TODO: initialize + static bool compareMemEntries(const MemoryTraceEntry& left, const MemoryTraceEntry& right); void insertInMemTrace(uint32_t m_clk, uint32_t m_sub_clk, uint32_t m_addr, FF m_val, bool m_rw); void loadAInMemTrace(uint32_t addr, FF val); diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp index 5021267c2d2e..25d3a6ba5e7f 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp @@ -28,9 +28,9 @@ template struct AvmMiniFullRow { FF memTrace_m_lastAccess{}; FF memTrace_m_rw{}; FF avmMini_pc{}; - FF avmMini_ret_ptr{}; - FF avmMini_sel_jump{}; - FF avmMini_sel_ret{}; + FF avmMini_internal_return_ptr{}; + FF avmMini_sel_internal_call{}; + FF avmMini_sel_internal_return{}; FF avmMini_sel_op_add{}; FF avmMini_sel_op_sub{}; FF avmMini_sel_op_mul{}; @@ -50,11 +50,11 @@ template struct AvmMiniFullRow { FF avmMini_mem_idx_b{}; FF avmMini_mem_idx_c{}; FF avmMini_last{}; + FF memTrace_m_addr_shift{}; FF memTrace_m_val_shift{}; FF memTrace_m_rw_shift{}; - FF memTrace_m_addr_shift{}; - FF avmMini_ret_ptr_shift{}; FF avmMini_pc_shift{}; + FF avmMini_internal_return_ptr_shift{}; }; class AvmMiniCircuitBuilder { @@ -93,9 +93,9 @@ class AvmMiniCircuitBuilder { polys.memTrace_m_lastAccess[i] = rows[i].memTrace_m_lastAccess; polys.memTrace_m_rw[i] = rows[i].memTrace_m_rw; polys.avmMini_pc[i] = rows[i].avmMini_pc; - polys.avmMini_ret_ptr[i] = rows[i].avmMini_ret_ptr; - polys.avmMini_sel_jump[i] = rows[i].avmMini_sel_jump; - polys.avmMini_sel_ret[i] = rows[i].avmMini_sel_ret; + polys.avmMini_internal_return_ptr[i] = rows[i].avmMini_internal_return_ptr; + polys.avmMini_sel_internal_call[i] = rows[i].avmMini_sel_internal_call; + polys.avmMini_sel_internal_return[i] = rows[i].avmMini_sel_internal_return; polys.avmMini_sel_op_add[i] = rows[i].avmMini_sel_op_add; polys.avmMini_sel_op_sub[i] = rows[i].avmMini_sel_op_sub; polys.avmMini_sel_op_mul[i] = rows[i].avmMini_sel_op_mul; @@ -117,11 +117,11 @@ class AvmMiniCircuitBuilder { polys.avmMini_last[i] = rows[i].avmMini_last; } + polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); - polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); - polys.avmMini_ret_ptr_shift = Polynomial(polys.avmMini_ret_ptr.shifted()); polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); + polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); return polys; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp index 9b5b63d12830..ed1902ead67d 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp @@ -7,33 +7,37 @@ namespace proof_system::AvmMini_vm { template struct Avm_miniRow { - FF avmMini_rwa{}; - FF avmMini_ret_ptr_shift{}; - FF avmMini_pc{}; - FF avmMini_sel_jump{}; - FF avmMini_rwb{}; + FF avmMini_sel_op_add{}; + FF avmMini_sel_op_mul{}; + FF avmMini_op_err{}; + FF avmMini_mem_op_a{}; + FF avmMini_ic{}; FF avmMini_inv{}; + FF avmMini_rwa{}; + FF avmMini_mem_idx_a{}; + FF avmMini_first{}; FF avmMini_sel_op_sub{}; - FF avmMini_ia{}; FF avmMini_ib{}; FF avmMini_pc_shift{}; - FF avmMini_mem_op_a{}; FF avmMini_sel_op_div{}; - FF avmMini_sel_op_mul{}; - FF avmMini_mem_idx_a{}; + FF avmMini_sel_internal_return{}; + FF avmMini_pc{}; + FF avmMini_internal_return_ptr_shift{}; + FF avmMini_mem_op_c{}; + FF avmMini_rwb{}; FF avmMini_rwc{}; - FF avmMini_sel_op_add{}; + FF avmMini_ia{}; + FF avmMini_sel_internal_call{}; FF avmMini_mem_op_b{}; - FF avmMini_op_err{}; - FF avmMini_ic{}; - FF avmMini_sel_ret{}; - FF avmMini_mem_op_c{}; - FF avmMini_ret_ptr{}; + FF avmMini_internal_return_ptr{}; }; inline std::string get_relation_label_avm_mini(int index) { - switch (index) {} + switch (index) { + case 28: + return "pc_increment"; + } return std::to_string(index); } @@ -200,7 +204,8 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(18); - auto tmp = (avmMini_sel_jump * (avmMini_ret_ptr_shift - (avmMini_ret_ptr + FF(1)))); + auto tmp = (avmMini_sel_internal_call * + (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr + FF(1)))); tmp *= scaling_factor; std::get<18>(evals) += tmp; } @@ -208,7 +213,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(19); - auto tmp = (avmMini_sel_jump * (avmMini_ret_ptr - avmMini_mem_idx_a)); + auto tmp = (avmMini_sel_internal_call * (avmMini_internal_return_ptr - avmMini_mem_idx_a)); tmp *= scaling_factor; std::get<19>(evals) += tmp; } @@ -216,7 +221,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(20); - auto tmp = (avmMini_sel_jump * (avmMini_rwa - FF(1))); + auto tmp = (avmMini_sel_internal_call * (avmMini_rwa - FF(1))); tmp *= scaling_factor; std::get<20>(evals) += tmp; } @@ -224,7 +229,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(21); - auto tmp = (avmMini_sel_jump * (avmMini_mem_op_a - FF(1))); + auto tmp = (avmMini_sel_internal_call * (avmMini_mem_op_a - FF(1))); tmp *= scaling_factor; std::get<21>(evals) += tmp; } @@ -232,7 +237,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(22); - auto tmp = (avmMini_sel_jump * (avmMini_pc_shift - avmMini_ia)); + auto tmp = (avmMini_sel_internal_call * (avmMini_pc_shift - avmMini_ia)); tmp *= scaling_factor; std::get<22>(evals) += tmp; } @@ -240,7 +245,8 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(23); - auto tmp = (avmMini_sel_ret * (avmMini_ret_ptr_shift - (avmMini_ret_ptr - FF(1)))); + auto tmp = (avmMini_sel_internal_return * + (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr - FF(1)))); tmp *= scaling_factor; std::get<23>(evals) += tmp; } @@ -248,7 +254,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(24); - auto tmp = (avmMini_sel_ret * (avmMini_ret_ptr - avmMini_mem_idx_a)); + auto tmp = (avmMini_sel_internal_return * (avmMini_internal_return_ptr - avmMini_mem_idx_a)); tmp *= scaling_factor; std::get<24>(evals) += tmp; } @@ -256,7 +262,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(25); - auto tmp = (avmMini_sel_ret * (avmMini_pc_shift - avmMini_ia)); + auto tmp = (avmMini_sel_internal_return * (avmMini_pc_shift - avmMini_ia)); tmp *= scaling_factor; std::get<25>(evals) += tmp; } @@ -264,7 +270,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(26); - auto tmp = (avmMini_sel_ret * avmMini_rwa); + auto tmp = (avmMini_sel_internal_return * avmMini_rwa); tmp *= scaling_factor; std::get<26>(evals) += tmp; } @@ -272,7 +278,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(27); - auto tmp = (avmMini_sel_ret * (avmMini_mem_op_a - FF(1))); + auto tmp = (avmMini_sel_internal_return * (avmMini_mem_op_a - FF(1))); tmp *= scaling_factor; std::get<27>(evals) += tmp; } @@ -280,7 +286,11 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(28); - auto tmp = (((-avmMini_sel_jump + FF(1)) * (-avmMini_sel_ret + FF(1))) * + auto tmp = (((-avmMini_first + FF(1)) * + (((((avmMini_sel_internal_call + avmMini_sel_internal_return) + avmMini_sel_op_add) + + avmMini_sel_op_sub) + + avmMini_sel_op_div) + + avmMini_sel_op_mul)) * (avmMini_pc_shift - (avmMini_pc + FF(1)))); tmp *= scaling_factor; std::get<28>(evals) += tmp; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp index 5beb7d49b548..8b0ee65439d7 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp @@ -11,9 +11,9 @@ [[maybe_unused]] auto memTrace_m_lastAccess = View(new_term.memTrace_m_lastAccess); \ [[maybe_unused]] auto memTrace_m_rw = View(new_term.memTrace_m_rw); \ [[maybe_unused]] auto avmMini_pc = View(new_term.avmMini_pc); \ - [[maybe_unused]] auto avmMini_ret_ptr = View(new_term.avmMini_ret_ptr); \ - [[maybe_unused]] auto avmMini_sel_jump = View(new_term.avmMini_sel_jump); \ - [[maybe_unused]] auto avmMini_sel_ret = View(new_term.avmMini_sel_ret); \ + [[maybe_unused]] auto avmMini_internal_return_ptr = View(new_term.avmMini_internal_return_ptr); \ + [[maybe_unused]] auto avmMini_sel_internal_call = View(new_term.avmMini_sel_internal_call); \ + [[maybe_unused]] auto avmMini_sel_internal_return = View(new_term.avmMini_sel_internal_return); \ [[maybe_unused]] auto avmMini_sel_op_add = View(new_term.avmMini_sel_op_add); \ [[maybe_unused]] auto avmMini_sel_op_sub = View(new_term.avmMini_sel_op_sub); \ [[maybe_unused]] auto avmMini_sel_op_mul = View(new_term.avmMini_sel_op_mul); \ @@ -33,8 +33,8 @@ [[maybe_unused]] auto avmMini_mem_idx_b = View(new_term.avmMini_mem_idx_b); \ [[maybe_unused]] auto avmMini_mem_idx_c = View(new_term.avmMini_mem_idx_c); \ [[maybe_unused]] auto avmMini_last = View(new_term.avmMini_last); \ + [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ - [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ - [[maybe_unused]] auto avmMini_ret_ptr_shift = View(new_term.avmMini_ret_ptr_shift); \ - [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); + [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ + [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp index 5282fb62148b..a835cdab8fd2 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp @@ -7,15 +7,15 @@ namespace proof_system::AvmMini_vm { template struct Mem_traceRow { + FF avmMini_last{}; + FF memTrace_m_addr_shift{}; + FF memTrace_m_addr{}; FF memTrace_m_val_shift{}; - FF memTrace_m_val{}; + FF avmMini_first{}; FF memTrace_m_lastAccess{}; - FF memTrace_m_rw_shift{}; - FF memTrace_m_addr{}; + FF memTrace_m_val{}; FF memTrace_m_rw{}; - FF memTrace_m_addr_shift{}; - FF avmMini_first{}; - FF avmMini_last{}; + FF memTrace_m_rw_shift{}; }; inline std::string get_relation_label_mem_trace(int index) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp index 91f5a44b4f86..cd737737aaa5 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp @@ -26,9 +26,9 @@ void AvmMiniComposer::compute_witness(CircuitConstructor& circuit) proving_key->memTrace_m_lastAccess = polynomials.memTrace_m_lastAccess; proving_key->memTrace_m_rw = polynomials.memTrace_m_rw; proving_key->avmMini_pc = polynomials.avmMini_pc; - proving_key->avmMini_ret_ptr = polynomials.avmMini_ret_ptr; - proving_key->avmMini_sel_jump = polynomials.avmMini_sel_jump; - proving_key->avmMini_sel_ret = polynomials.avmMini_sel_ret; + proving_key->avmMini_internal_return_ptr = polynomials.avmMini_internal_return_ptr; + proving_key->avmMini_sel_internal_call = polynomials.avmMini_sel_internal_call; + proving_key->avmMini_sel_internal_return = polynomials.avmMini_sel_internal_return; proving_key->avmMini_sel_op_add = polynomials.avmMini_sel_op_add; proving_key->avmMini_sel_op_sub = polynomials.avmMini_sel_op_sub; proving_key->avmMini_sel_op_mul = polynomials.avmMini_sel_op_mul; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp index 11f1ce8c9c34..8374e17394d8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp @@ -39,9 +39,9 @@ AvmMiniProver::AvmMiniProver(std::shared_ptr input_key, prover_polynomials.memTrace_m_lastAccess = key->memTrace_m_lastAccess; prover_polynomials.memTrace_m_rw = key->memTrace_m_rw; prover_polynomials.avmMini_pc = key->avmMini_pc; - prover_polynomials.avmMini_ret_ptr = key->avmMini_ret_ptr; - prover_polynomials.avmMini_sel_jump = key->avmMini_sel_jump; - prover_polynomials.avmMini_sel_ret = key->avmMini_sel_ret; + prover_polynomials.avmMini_internal_return_ptr = key->avmMini_internal_return_ptr; + prover_polynomials.avmMini_sel_internal_call = key->avmMini_sel_internal_call; + prover_polynomials.avmMini_sel_internal_return = key->avmMini_sel_internal_return; prover_polynomials.avmMini_sel_op_add = key->avmMini_sel_op_add; prover_polynomials.avmMini_sel_op_sub = key->avmMini_sel_op_sub; prover_polynomials.avmMini_sel_op_mul = key->avmMini_sel_op_mul; @@ -62,21 +62,21 @@ AvmMiniProver::AvmMiniProver(std::shared_ptr input_key, prover_polynomials.avmMini_mem_idx_c = key->avmMini_mem_idx_c; prover_polynomials.avmMini_last = key->avmMini_last; + prover_polynomials.memTrace_m_addr = key->memTrace_m_addr; + prover_polynomials.memTrace_m_addr_shift = key->memTrace_m_addr.shifted(); + prover_polynomials.memTrace_m_val = key->memTrace_m_val; prover_polynomials.memTrace_m_val_shift = key->memTrace_m_val.shifted(); prover_polynomials.memTrace_m_rw = key->memTrace_m_rw; prover_polynomials.memTrace_m_rw_shift = key->memTrace_m_rw.shifted(); - prover_polynomials.memTrace_m_addr = key->memTrace_m_addr; - prover_polynomials.memTrace_m_addr_shift = key->memTrace_m_addr.shifted(); - - prover_polynomials.avmMini_ret_ptr = key->avmMini_ret_ptr; - prover_polynomials.avmMini_ret_ptr_shift = key->avmMini_ret_ptr.shifted(); - prover_polynomials.avmMini_pc = key->avmMini_pc; prover_polynomials.avmMini_pc_shift = key->avmMini_pc.shifted(); + prover_polynomials.avmMini_internal_return_ptr = key->avmMini_internal_return_ptr; + prover_polynomials.avmMini_internal_return_ptr_shift = key->avmMini_internal_return_ptr.shifted(); + // prover_polynomials.lookup_inverses = key->lookup_inverses; // key->z_perm = Polynomial(key->circuit_size); // prover_polynomials.z_perm = key->z_perm; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp index 1365b676b210..5a3eb8d7b874 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp @@ -65,12 +65,12 @@ bool AvmMiniVerifier::verify_proof(const plonk::proof& proof) transcript->template receive_from_prover(commitment_labels.memTrace_m_lastAccess); commitments.memTrace_m_rw = transcript->template receive_from_prover(commitment_labels.memTrace_m_rw); commitments.avmMini_pc = transcript->template receive_from_prover(commitment_labels.avmMini_pc); - commitments.avmMini_ret_ptr = - transcript->template receive_from_prover(commitment_labels.avmMini_ret_ptr); - commitments.avmMini_sel_jump = - transcript->template receive_from_prover(commitment_labels.avmMini_sel_jump); - commitments.avmMini_sel_ret = - transcript->template receive_from_prover(commitment_labels.avmMini_sel_ret); + commitments.avmMini_internal_return_ptr = + transcript->template receive_from_prover(commitment_labels.avmMini_internal_return_ptr); + commitments.avmMini_sel_internal_call = + transcript->template receive_from_prover(commitment_labels.avmMini_sel_internal_call); + commitments.avmMini_sel_internal_return = + transcript->template receive_from_prover(commitment_labels.avmMini_sel_internal_return); commitments.avmMini_sel_op_add = transcript->template receive_from_prover(commitment_labels.avmMini_sel_op_add); commitments.avmMini_sel_op_sub = diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp index 1a94d54816e5..928f4b7cc09a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp @@ -46,6 +46,8 @@ void validateTraceProof(std::vector&& trace) auto circuit_builder = AvmMiniCircuitBuilder(); circuit_builder.set_trace(std::move(trace)); + log_avmMini_trace(circuit_builder.rows, 10, 13); + EXPECT_TRUE(circuit_builder.check_circuit()); auto composer = honk::AvmMiniComposer(); @@ -121,6 +123,7 @@ void mutateIcInTrace(std::vector& trace, std::function&& selectR // Test on basic addition over finite field type. TEST_F(AvmMiniArithmeticTests, additionFF) { + // trace_builder trace_builder.callDataCopy(0, 3, 0, std::vector{ 37, 4, 11 }); // Memory layout: [37,4,11,0,0,0,....] @@ -128,6 +131,8 @@ TEST_F(AvmMiniArithmeticTests, additionFF) trace_builder.returnOP(0, 5); auto trace = trace_builder.finalize(); + info("Built circuit with ", trace.size(), " rows"); + // Find the first row enabling the addition selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_add == FF(1); }); From 17057c874ac33c6512fde8a75a681e8f3e03c80c Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 18 Dec 2023 12:38:23 +0000 Subject: [PATCH 03/10] fix: add halt flag to stop pc progression --- barretenberg/cpp/pil/avm/avm_mini.pil | 6 ++-- .../flavor/generated/AvmMini_flavor.hpp | 27 ++++++++++----- .../circuit_builder/AvmMini_trace.cpp | 15 ++++++++- .../circuit_builder/AvmMini_trace.hpp | 3 ++ .../generated/AvmMini_circuit_builder.hpp | 14 ++++---- .../relations/generated/AvmMini/avm_mini.hpp | 33 ++++++++++--------- .../generated/AvmMini/declare_views.hpp | 5 +-- .../relations/generated/AvmMini/mem_trace.hpp | 12 +++---- .../vm/generated/AvmMini_composer.cpp | 1 + .../vm/generated/AvmMini_prover.cpp | 9 ++--- .../vm/generated/AvmMini_verifier.cpp | 2 ++ .../vm/tests/AvmMini_arithmetic.test.cpp | 4 +-- 12 files changed, 83 insertions(+), 48 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index 5d9b50cba1d8..c10f07824de2 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -16,7 +16,9 @@ namespace avmMini(256); pol commit sel_internal_call; pol commit sel_internal_return; - + + // Halt program execution + pol commit sel_halt; //===== TABLE SUBOP-TR ======================================================== // Boolean selectors for (sub-)operations. Only one operation is activated at @@ -140,7 +142,7 @@ namespace avmMini(256); // Program counter must increment if not jumping or returning #[pc_increment] - (1-first) * (sel_internal_call + sel_internal_return + sel_op_add + sel_op_sub + sel_op_div + sel_op_mul) * (pc' - (pc + 1)) = 0; + (1-first) * (1- sel_halt) * (sel_internal_call + sel_internal_return + sel_op_add + sel_op_sub + sel_op_div + sel_op_mul) * (pc' - (pc + 1)) = 0; // TODO: we want to set an initial number for the reserved memory of the jump pointer diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp index f4384833874a..8d586fe1804f 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp @@ -36,11 +36,11 @@ class AvmMiniFlavor { using VerifierCommitmentKey = pcs::VerifierCommitmentKey; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2; - static constexpr size_t NUM_WITNESS_ENTITIES = 29; + static constexpr size_t NUM_WITNESS_ENTITIES = 30; 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 = 36; + static constexpr size_t NUM_ALL_ENTITIES = 37; using Relations = std::tuple, AvmMini_vm::avm_mini>; @@ -86,6 +86,7 @@ class AvmMiniFlavor { avmMini_internal_return_ptr, avmMini_sel_internal_call, avmMini_sel_internal_return, + avmMini_sel_halt, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -118,6 +119,7 @@ class AvmMiniFlavor { avmMini_internal_return_ptr, avmMini_sel_internal_call, avmMini_sel_internal_return, + avmMini_sel_halt, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -156,6 +158,7 @@ class AvmMiniFlavor { avmMini_internal_return_ptr, avmMini_sel_internal_call, avmMini_sel_internal_return, + avmMini_sel_halt, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -175,9 +178,9 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, - memTrace_m_addr_shift, - memTrace_m_val_shift, memTrace_m_rw_shift, + memTrace_m_val_shift, + memTrace_m_addr_shift, avmMini_pc_shift, avmMini_internal_return_ptr_shift) @@ -195,6 +198,7 @@ class AvmMiniFlavor { avmMini_internal_return_ptr, avmMini_sel_internal_call, avmMini_sel_internal_return, + avmMini_sel_halt, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -214,9 +218,9 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, - memTrace_m_addr_shift, - memTrace_m_val_shift, memTrace_m_rw_shift, + memTrace_m_val_shift, + memTrace_m_addr_shift, avmMini_pc_shift, avmMini_internal_return_ptr_shift }; }; @@ -234,6 +238,7 @@ class AvmMiniFlavor { avmMini_internal_return_ptr, avmMini_sel_internal_call, avmMini_sel_internal_return, + avmMini_sel_halt, avmMini_sel_op_add, avmMini_sel_op_sub, avmMini_sel_op_mul, @@ -256,13 +261,13 @@ class AvmMiniFlavor { }; RefVector get_to_be_shifted() { - return { memTrace_m_addr, memTrace_m_val, memTrace_m_rw, avmMini_pc, avmMini_internal_return_ptr }; + return { memTrace_m_rw, memTrace_m_val, memTrace_m_addr, avmMini_pc, avmMini_internal_return_ptr }; }; RefVector get_shifted() { - return { memTrace_m_addr_shift, + return { memTrace_m_rw_shift, memTrace_m_val_shift, - memTrace_m_rw_shift, + memTrace_m_addr_shift, avmMini_pc_shift, avmMini_internal_return_ptr_shift }; }; @@ -349,6 +354,7 @@ class AvmMiniFlavor { Base::avmMini_internal_return_ptr = "AVMMINI_INTERNAL_RETURN_PTR"; Base::avmMini_sel_internal_call = "AVMMINI_SEL_INTERNAL_CALL"; Base::avmMini_sel_internal_return = "AVMMINI_SEL_INTERNAL_RETURN"; + Base::avmMini_sel_halt = "AVMMINI_SEL_HALT"; Base::avmMini_sel_op_add = "AVMMINI_SEL_OP_ADD"; Base::avmMini_sel_op_sub = "AVMMINI_SEL_OP_SUB"; Base::avmMini_sel_op_mul = "AVMMINI_SEL_OP_MUL"; @@ -397,6 +403,7 @@ class AvmMiniFlavor { Commitment avmMini_internal_return_ptr; Commitment avmMini_sel_internal_call; Commitment avmMini_sel_internal_return; + Commitment avmMini_sel_halt; Commitment avmMini_sel_op_add; Commitment avmMini_sel_op_sub; Commitment avmMini_sel_op_mul; @@ -445,6 +452,7 @@ class AvmMiniFlavor { avmMini_internal_return_ptr = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_internal_call = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_internal_return = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); + avmMini_sel_halt = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_op_add = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_op_sub = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); avmMini_sel_op_mul = deserialize_from_buffer(Transcript::proof_data, num_bytes_read); @@ -497,6 +505,7 @@ class AvmMiniFlavor { serialize_to_buffer(avmMini_internal_return_ptr, Transcript::proof_data); serialize_to_buffer(avmMini_sel_internal_call, Transcript::proof_data); serialize_to_buffer(avmMini_sel_internal_return, Transcript::proof_data); + serialize_to_buffer(avmMini_sel_halt, Transcript::proof_data); serialize_to_buffer(avmMini_sel_op_add, Transcript::proof_data); serialize_to_buffer(avmMini_sel_op_sub, Transcript::proof_data); serialize_to_buffer(avmMini_sel_op_mul, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index b1ebdfcfc1b3..216341898f5e 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -507,7 +507,8 @@ std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSi mainTrace.push_back(Row{ .avmMini_clk = clk, - .avmMini_pc = FF(pc++), + .avmMini_pc = FF(pc), + .avmMini_sel_halt = FF(1), .avmMini_ia = ia, .avmMini_ib = ib, .avmMini_ic = ic, @@ -528,6 +529,18 @@ std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSi return returnMem; } +// TODO: doc +void AvmMiniTraceBuilder::halt() +{ + auto clk = mainTrace.size(); + + mainTrace.push_back(Row{ + .avmMini_clk = clk, + .avmMini_pc = FF(pc), + .avmMini_sel_halt = FF(1), + }); +} + void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) { auto clk = mainTrace.size(); diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp index c3609c1abf83..880abca667fe 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp @@ -63,6 +63,9 @@ class AvmMiniTraceBuilder { // Return from a jump. void internal_return(); + // Halt -> stop program execution. + void halt(); + // CALLDATACOPY opcode with direct memory access, i.e., // M[dstOffset:dstOffset+copySize] = calldata[cdOffset:cdOffset+copySize] void callDataCopy(uint32_t cdOffset, uint32_t copySize, uint32_t dstOffset, std::vector const& callDataMem); diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp index 25d3a6ba5e7f..cbe8e4ad91f4 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp @@ -31,6 +31,7 @@ template struct AvmMiniFullRow { FF avmMini_internal_return_ptr{}; FF avmMini_sel_internal_call{}; FF avmMini_sel_internal_return{}; + FF avmMini_sel_halt{}; FF avmMini_sel_op_add{}; FF avmMini_sel_op_sub{}; FF avmMini_sel_op_mul{}; @@ -50,9 +51,9 @@ template struct AvmMiniFullRow { FF avmMini_mem_idx_b{}; FF avmMini_mem_idx_c{}; FF avmMini_last{}; - FF memTrace_m_addr_shift{}; - FF memTrace_m_val_shift{}; FF memTrace_m_rw_shift{}; + FF memTrace_m_val_shift{}; + FF memTrace_m_addr_shift{}; FF avmMini_pc_shift{}; FF avmMini_internal_return_ptr_shift{}; }; @@ -67,8 +68,8 @@ class AvmMiniCircuitBuilder { using Polynomial = Flavor::Polynomial; using AllPolynomials = Flavor::AllPolynomials; - static constexpr size_t num_fixed_columns = 36; - static constexpr size_t num_polys = 31; + static constexpr size_t num_fixed_columns = 37; + static constexpr size_t num_polys = 32; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -96,6 +97,7 @@ class AvmMiniCircuitBuilder { polys.avmMini_internal_return_ptr[i] = rows[i].avmMini_internal_return_ptr; polys.avmMini_sel_internal_call[i] = rows[i].avmMini_sel_internal_call; polys.avmMini_sel_internal_return[i] = rows[i].avmMini_sel_internal_return; + polys.avmMini_sel_halt[i] = rows[i].avmMini_sel_halt; polys.avmMini_sel_op_add[i] = rows[i].avmMini_sel_op_add; polys.avmMini_sel_op_sub[i] = rows[i].avmMini_sel_op_sub; polys.avmMini_sel_op_mul[i] = rows[i].avmMini_sel_op_mul; @@ -117,9 +119,9 @@ class AvmMiniCircuitBuilder { polys.avmMini_last[i] = rows[i].avmMini_last; } - polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); - polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); + polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); + polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp index ed1902ead67d..61f3f130d506 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp @@ -7,29 +7,30 @@ namespace proof_system::AvmMini_vm { template struct Avm_miniRow { + FF avmMini_rwb{}; + FF avmMini_internal_return_ptr{}; + FF avmMini_mem_idx_a{}; + FF avmMini_pc_shift{}; + FF avmMini_mem_op_b{}; + FF avmMini_sel_op_div{}; FF avmMini_sel_op_add{}; - FF avmMini_sel_op_mul{}; - FF avmMini_op_err{}; FF avmMini_mem_op_a{}; + FF avmMini_internal_return_ptr_shift{}; + FF avmMini_ia{}; FF avmMini_ic{}; - FF avmMini_inv{}; + FF avmMini_ib{}; FF avmMini_rwa{}; - FF avmMini_mem_idx_a{}; - FF avmMini_first{}; + FF avmMini_sel_internal_call{}; FF avmMini_sel_op_sub{}; - FF avmMini_ib{}; - FF avmMini_pc_shift{}; - FF avmMini_sel_op_div{}; + FF avmMini_sel_op_mul{}; + FF avmMini_op_err{}; FF avmMini_sel_internal_return{}; + FF avmMini_sel_halt{}; FF avmMini_pc{}; - FF avmMini_internal_return_ptr_shift{}; FF avmMini_mem_op_c{}; - FF avmMini_rwb{}; + FF avmMini_first{}; FF avmMini_rwc{}; - FF avmMini_ia{}; - FF avmMini_sel_internal_call{}; - FF avmMini_mem_op_b{}; - FF avmMini_internal_return_ptr{}; + FF avmMini_inv{}; }; inline std::string get_relation_label_avm_mini(int index) @@ -46,7 +47,7 @@ template class avm_miniImpl { using FF = FF_; static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, }; template @@ -286,7 +287,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(28); - auto tmp = (((-avmMini_first + FF(1)) * + auto tmp = ((((-avmMini_first + FF(1)) * (-avmMini_sel_halt + FF(1))) * (((((avmMini_sel_internal_call + avmMini_sel_internal_return) + avmMini_sel_op_add) + avmMini_sel_op_sub) + avmMini_sel_op_div) + diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp index 8b0ee65439d7..643c7c9a3e05 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp @@ -14,6 +14,7 @@ [[maybe_unused]] auto avmMini_internal_return_ptr = View(new_term.avmMini_internal_return_ptr); \ [[maybe_unused]] auto avmMini_sel_internal_call = View(new_term.avmMini_sel_internal_call); \ [[maybe_unused]] auto avmMini_sel_internal_return = View(new_term.avmMini_sel_internal_return); \ + [[maybe_unused]] auto avmMini_sel_halt = View(new_term.avmMini_sel_halt); \ [[maybe_unused]] auto avmMini_sel_op_add = View(new_term.avmMini_sel_op_add); \ [[maybe_unused]] auto avmMini_sel_op_sub = View(new_term.avmMini_sel_op_sub); \ [[maybe_unused]] auto avmMini_sel_op_mul = View(new_term.avmMini_sel_op_mul); \ @@ -33,8 +34,8 @@ [[maybe_unused]] auto avmMini_mem_idx_b = View(new_term.avmMini_mem_idx_b); \ [[maybe_unused]] auto avmMini_mem_idx_c = View(new_term.avmMini_mem_idx_c); \ [[maybe_unused]] auto avmMini_last = View(new_term.avmMini_last); \ - [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ - [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ + [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ + [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp index a835cdab8fd2..497224f9856a 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp @@ -7,15 +7,15 @@ namespace proof_system::AvmMini_vm { template struct Mem_traceRow { - FF avmMini_last{}; - FF memTrace_m_addr_shift{}; FF memTrace_m_addr{}; - FF memTrace_m_val_shift{}; FF avmMini_first{}; - FF memTrace_m_lastAccess{}; - FF memTrace_m_val{}; - FF memTrace_m_rw{}; + FF avmMini_last{}; FF memTrace_m_rw_shift{}; + FF memTrace_m_rw{}; + FF memTrace_m_val_shift{}; + FF memTrace_m_val{}; + FF memTrace_m_lastAccess{}; + FF memTrace_m_addr_shift{}; }; inline std::string get_relation_label_mem_trace(int index) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp index cd737737aaa5..18459b837557 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp @@ -29,6 +29,7 @@ void AvmMiniComposer::compute_witness(CircuitConstructor& circuit) proving_key->avmMini_internal_return_ptr = polynomials.avmMini_internal_return_ptr; proving_key->avmMini_sel_internal_call = polynomials.avmMini_sel_internal_call; proving_key->avmMini_sel_internal_return = polynomials.avmMini_sel_internal_return; + proving_key->avmMini_sel_halt = polynomials.avmMini_sel_halt; proving_key->avmMini_sel_op_add = polynomials.avmMini_sel_op_add; proving_key->avmMini_sel_op_sub = polynomials.avmMini_sel_op_sub; proving_key->avmMini_sel_op_mul = polynomials.avmMini_sel_op_mul; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp index 8374e17394d8..0f092f5f4074 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp @@ -42,6 +42,7 @@ AvmMiniProver::AvmMiniProver(std::shared_ptr input_key, prover_polynomials.avmMini_internal_return_ptr = key->avmMini_internal_return_ptr; prover_polynomials.avmMini_sel_internal_call = key->avmMini_sel_internal_call; prover_polynomials.avmMini_sel_internal_return = key->avmMini_sel_internal_return; + prover_polynomials.avmMini_sel_halt = key->avmMini_sel_halt; prover_polynomials.avmMini_sel_op_add = key->avmMini_sel_op_add; prover_polynomials.avmMini_sel_op_sub = key->avmMini_sel_op_sub; prover_polynomials.avmMini_sel_op_mul = key->avmMini_sel_op_mul; @@ -62,14 +63,14 @@ AvmMiniProver::AvmMiniProver(std::shared_ptr input_key, prover_polynomials.avmMini_mem_idx_c = key->avmMini_mem_idx_c; prover_polynomials.avmMini_last = key->avmMini_last; - prover_polynomials.memTrace_m_addr = key->memTrace_m_addr; - prover_polynomials.memTrace_m_addr_shift = key->memTrace_m_addr.shifted(); + prover_polynomials.memTrace_m_rw = key->memTrace_m_rw; + prover_polynomials.memTrace_m_rw_shift = key->memTrace_m_rw.shifted(); prover_polynomials.memTrace_m_val = key->memTrace_m_val; prover_polynomials.memTrace_m_val_shift = key->memTrace_m_val.shifted(); - prover_polynomials.memTrace_m_rw = key->memTrace_m_rw; - prover_polynomials.memTrace_m_rw_shift = key->memTrace_m_rw.shifted(); + prover_polynomials.memTrace_m_addr = key->memTrace_m_addr; + prover_polynomials.memTrace_m_addr_shift = key->memTrace_m_addr.shifted(); prover_polynomials.avmMini_pc = key->avmMini_pc; prover_polynomials.avmMini_pc_shift = key->avmMini_pc.shifted(); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp index 5a3eb8d7b874..4cd178e3447b 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_verifier.cpp @@ -71,6 +71,8 @@ bool AvmMiniVerifier::verify_proof(const plonk::proof& proof) transcript->template receive_from_prover(commitment_labels.avmMini_sel_internal_call); commitments.avmMini_sel_internal_return = transcript->template receive_from_prover(commitment_labels.avmMini_sel_internal_return); + commitments.avmMini_sel_halt = + transcript->template receive_from_prover(commitment_labels.avmMini_sel_halt); commitments.avmMini_sel_op_add = transcript->template receive_from_prover(commitment_labels.avmMini_sel_op_add); commitments.avmMini_sel_op_sub = diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp index 928f4b7cc09a..6447c6101ccb 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp @@ -46,8 +46,6 @@ void validateTraceProof(std::vector&& trace) auto circuit_builder = AvmMiniCircuitBuilder(); circuit_builder.set_trace(std::move(trace)); - log_avmMini_trace(circuit_builder.rows, 10, 13); - EXPECT_TRUE(circuit_builder.check_circuit()); auto composer = honk::AvmMiniComposer(); @@ -269,6 +267,7 @@ TEST_F(AvmMiniArithmeticTests, divisionByZeroErrorFF) // Memory layout: [15,0,0,0,0,0,....] trace_builder.div(0, 1, 2); // [15,0,0,0,0,0....] + trace_builder.halt(); auto trace = trace_builder.finalize(); // Find the first row enabling the division selector @@ -303,6 +302,7 @@ TEST_F(AvmMiniArithmeticTests, arithmeticFFWithError) trace_builder.div(3, 5, 1); // [0,23*136^(-1),45,23,68,136,0,136,136^2,0....] trace_builder.div(1, 1, 9); // [0,23*136^(-1),45,23,68,136,0,136,136^2,1,0....] trace_builder.div(9, 0, 4); // [0,23*136^(-1),45,23,1/0,136,0,136,136^2,1,0....] Error: division by 0 + trace_builder.halt(); auto trace = trace_builder.finalize(); validateTraceProof(std::move(trace)); From abf939d37f67e302c712f1e59a2a000ed73cd91c Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 18 Dec 2023 20:48:13 +0000 Subject: [PATCH 04/10] temp --- barretenberg/cpp/pil/avm/avm_mini.pil | 4 +- .../flavor/generated/AvmMini_flavor.hpp | 53 +- .../flavor/generated/Toy_flavor.hpp | 26 +- .../circuit_builder/AvmMini_trace.cpp | 16 +- .../circuit_builder/AvmMini_trace.hpp | 2 +- .../generated/AvmMini_circuit_builder.hpp | 26 +- .../generated/Toy_circuit_builder.hpp | 17 +- .../relations/generated/AvmMini/avm_mini.hpp | 42 +- .../generated/AvmMini/declare_views.hpp | 6 +- .../relations/generated/AvmMini/mem_trace.hpp | 8 +- .../relations/generated/Toy/toy_avm.hpp | 8 +- .../vm/generated/AvmMini_composer.cpp | 36 +- .../vm/generated/AvmMini_prover.cpp | 62 +-- .../vm/generated/Toy_composer.cpp | 12 +- .../barretenberg/vm/generated/Toy_prover.cpp | 26 +- .../vm/tests/AvmMini_control_flow.test.cpp | 506 ++++++++++++++++++ 16 files changed, 668 insertions(+), 182 deletions(-) create mode 100644 barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index c10f07824de2..9ff602122a94 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -127,13 +127,15 @@ namespace avmMini(256); // The program counter in the next row should be equal to the value loaded from the ia register // This implies that a load from memory must occur at the same time // Imply that we must load the jump selector into mema + #[return_pointer_increment] sel_internal_call * ( internal_return_ptr' - ( internal_return_ptr + 1)) = 0; // we increment our jump selector sel_internal_call * ( internal_return_ptr - mem_idx_a) = 0; sel_internal_call * (rwa - 1) = 0; // it must be a write sel_internal_call * (mem_op_a - 1) = 0; - sel_internal_call * (pc' - ia) = 0; + sel_internal_call * (pc - ia) = 0; // We must load the memory pointer to be the internal_return_ptr + #[return_pointer_decrement] sel_internal_return * ( internal_return_ptr' - ( internal_return_ptr - 1)) = 0; // We decrement out jump selector sel_internal_return * ( internal_return_ptr - mem_idx_a) = 0; sel_internal_return * (pc' - ia) = 0; diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp index 8d586fe1804f..2c09219f86a5 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp @@ -42,7 +42,7 @@ class AvmMiniFlavor { // the unshifted and one for the shifted static constexpr size_t NUM_ALL_ENTITIES = 37; - using Relations = std::tuple, AvmMini_vm::avm_mini>; + using Relations = std::tuple, AvmMini_vm::mem_trace>; static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); @@ -178,11 +178,11 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, + avmMini_pc_shift, + avmMini_internal_return_ptr_shift, memTrace_m_rw_shift, - memTrace_m_val_shift, memTrace_m_addr_shift, - avmMini_pc_shift, - avmMini_internal_return_ptr_shift) + memTrace_m_val_shift) RefVector get_wires() { @@ -218,11 +218,11 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, + avmMini_pc_shift, + avmMini_internal_return_ptr_shift, memTrace_m_rw_shift, - memTrace_m_val_shift, memTrace_m_addr_shift, - avmMini_pc_shift, - avmMini_internal_return_ptr_shift }; + memTrace_m_val_shift }; }; RefVector get_unshifted() { @@ -261,15 +261,15 @@ class AvmMiniFlavor { }; RefVector get_to_be_shifted() { - return { memTrace_m_rw, memTrace_m_val, memTrace_m_addr, avmMini_pc, avmMini_internal_return_ptr }; + return { avmMini_pc, avmMini_internal_return_ptr, memTrace_m_rw, memTrace_m_addr, memTrace_m_val }; }; RefVector get_shifted() { - return { memTrace_m_rw_shift, - memTrace_m_val_shift, + return { avmMini_pc_shift, + avmMini_internal_return_ptr_shift, + memTrace_m_rw_shift, memTrace_m_addr_shift, - avmMini_pc_shift, - avmMini_internal_return_ptr_shift }; + memTrace_m_val_shift }; }; }; @@ -280,14 +280,17 @@ class AvmMiniFlavor { using Base = ProvingKey_, WitnessEntities>; using Base::Base; + RefVector get_to_be_shifted() + { + return { avmMini_pc, avmMini_internal_return_ptr, memTrace_m_rw, memTrace_m_addr, memTrace_m_val }; + }; + // The plookup wires that store plookup read data. std::array get_table_column_wires() { return {}; }; }; using VerificationKey = VerificationKey_>; - using ProverPolynomials = AllEntities; - using FoldedPolynomials = AllEntities>; class AllValues : public AllEntities { @@ -296,13 +299,27 @@ class AvmMiniFlavor { using Base::Base; }; - class AllPolynomials : public AllEntities { + /** + * @brief A container for the prover polynomials handles. + */ + class ProverPolynomials : public AllEntities { public: - [[nodiscard]] size_t get_polynomial_size() const { return this->memTrace_m_clk.size(); } - [[nodiscard]] AllValues get_row(const size_t row_idx) const + // Define all operations as default, except move construction/assignment + ProverPolynomials() = default; + ProverPolynomials& operator=(const ProverPolynomials&) = delete; + ProverPolynomials(const ProverPolynomials& o) = delete; + ProverPolynomials(ProverPolynomials&& o) noexcept = default; + ProverPolynomials& operator=(ProverPolynomials&& o) noexcept = default; + ~ProverPolynomials() = default; + [[nodiscard]] size_t get_polynomial_size() const { return memTrace_m_clk.size(); } + /** + * @brief Returns the evaluations of all prover polynomials at one point on the boolean hypercube, which + * represents one row in the execution trace. + */ + [[nodiscard]] AllValues get_row(size_t row_idx) const { AllValues result; - for (auto [result_field, polynomial] : zip_view(result.get_all(), get_all())) { + for (auto [result_field, polynomial] : zip_view(result.get_all(), this->get_all())) { result_field = polynomial[row_idx]; } return result; diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/Toy_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/Toy_flavor.hpp index 540d9107b825..ad3f4799b58a 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/Toy_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/Toy_flavor.hpp @@ -126,14 +126,14 @@ class ToyFlavor { using Base = ProvingKey_, WitnessEntities>; using Base::Base; + RefVector get_to_be_shifted() { return { toy_x }; }; + // The plookup wires that store plookup read data. std::array get_table_column_wires() { return {}; }; }; using VerificationKey = VerificationKey_>; - using ProverPolynomials = AllEntities; - using FoldedPolynomials = AllEntities>; class AllValues : public AllEntities { @@ -142,13 +142,27 @@ class ToyFlavor { using Base::Base; }; - class AllPolynomials : public AllEntities { + /** + * @brief A container for the prover polynomials handles. + */ + class ProverPolynomials : public AllEntities { public: - [[nodiscard]] size_t get_polynomial_size() const { return this->toy_q_tuple_set.size(); } - [[nodiscard]] AllValues get_row(const size_t row_idx) const + // Define all operations as default, except move construction/assignment + ProverPolynomials() = default; + ProverPolynomials& operator=(const ProverPolynomials&) = delete; + ProverPolynomials(const ProverPolynomials& o) = delete; + ProverPolynomials(ProverPolynomials&& o) noexcept = default; + ProverPolynomials& operator=(ProverPolynomials&& o) noexcept = default; + ~ProverPolynomials() = default; + [[nodiscard]] size_t get_polynomial_size() const { return toy_q_tuple_set.size(); } + /** + * @brief Returns the evaluations of all prover polynomials at one point on the boolean hypercube, which + * represents one row in the execution trace. + */ + [[nodiscard]] AllValues get_row(size_t row_idx) const { AllValues result; - for (auto [result_field, polynomial] : zip_view(result.get_all(), get_all())) { + for (auto [result_field, polynomial] : zip_view(result.get_all(), this->get_all())) { result_field = polynomial[row_idx]; } return result; diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index 216341898f5e..2f69ccd6ae1b 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -186,6 +186,7 @@ void AvmMiniTraceBuilder::add(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), + .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_op_add = FF(1), .avmMini_ia = a, .avmMini_ib = b, @@ -229,6 +230,7 @@ void AvmMiniTraceBuilder::sub(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), + .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_op_sub = FF(1), .avmMini_ia = a, .avmMini_ib = b, @@ -272,6 +274,7 @@ void AvmMiniTraceBuilder::mul(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), + .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_op_mul = FF(1), .avmMini_ia = a, .avmMini_ib = b, @@ -329,6 +332,7 @@ void AvmMiniTraceBuilder::div(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), + .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_op_div = FF(1), .avmMini_op_err = error, .avmMini_inv = inv, @@ -421,6 +425,7 @@ void AvmMiniTraceBuilder::callDataCopy(uint32_t cdOffset, mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), + .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_ia = ia, .avmMini_ib = ib, .avmMini_ic = ic, @@ -508,6 +513,7 @@ std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSi mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc), + .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_halt = FF(1), .avmMini_ia = ia, .avmMini_ib = ib, @@ -534,9 +540,12 @@ void AvmMiniTraceBuilder::halt() { auto clk = mainTrace.size(); + info("pc at halt: ", pc); + mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc), + .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_halt = FF(1), }); } @@ -547,16 +556,17 @@ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) // TODO: make sure this is initialized internal_call_stack.push(pc); - FF a = ffMemory.at(internal_return_ptr); // We want to write the current pc to the memory location pointed by storeAInMemTrace(internal_return_ptr, FF(pc)); + // TODO: we need a better way to insert globals into the trace mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc), .avmMini_internal_return_ptr = FF(internal_return_ptr), - .avmMini_ia = a, + .avmMini_sel_internal_call = FF(1), + .avmMini_ia = pc, .avmMini_mem_op_a = FF(1), .avmMini_rwa = FF(1), .avmMini_mem_idx_a = FF(internal_return_ptr), @@ -580,6 +590,8 @@ void AvmMiniTraceBuilder::internal_return() mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = pc, + .avmMini_internal_return_ptr = FF(internal_return_ptr), + .avmMini_sel_internal_return = FF(1), .avmMini_ia = a, .avmMini_mem_op_a = FF(1), .avmMini_rwa = FF(0), diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp index 880abca667fe..f11fc8eae4d1 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp @@ -27,7 +27,7 @@ class AvmMiniTraceBuilder { // Number of rows static const size_t N = 256; static const size_t MEM_SIZE = 1024; - static const size_t CALLSTACK_OFFSET = 1024; // TODO is this the vibe + static const size_t CALLSTACK_OFFSET = 896; // TODO is this the vibe - i assume not static const uint32_t SUB_CLK_LOAD_A = 0; static const uint32_t SUB_CLK_LOAD_B = 1; diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp index cbe8e4ad91f4..2858f284a42b 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp @@ -51,11 +51,11 @@ template struct AvmMiniFullRow { FF avmMini_mem_idx_b{}; FF avmMini_mem_idx_c{}; FF avmMini_last{}; - FF memTrace_m_rw_shift{}; - FF memTrace_m_val_shift{}; - FF memTrace_m_addr_shift{}; FF avmMini_pc_shift{}; FF avmMini_internal_return_ptr_shift{}; + FF memTrace_m_rw_shift{}; + FF memTrace_m_addr_shift{}; + FF memTrace_m_val_shift{}; }; class AvmMiniCircuitBuilder { @@ -66,7 +66,7 @@ class AvmMiniCircuitBuilder { // TODO: template using Polynomial = Flavor::Polynomial; - using AllPolynomials = Flavor::AllPolynomials; + using ProverPolynomials = Flavor::ProverPolynomials; static constexpr size_t num_fixed_columns = 37; static constexpr size_t num_polys = 32; @@ -74,10 +74,10 @@ class AvmMiniCircuitBuilder { void set_trace(std::vector&& trace) { rows = std::move(trace); } - AllPolynomials compute_polynomials() + ProverPolynomials compute_polynomials() { const auto num_rows = get_circuit_subgroup_size(); - AllPolynomials polys; + ProverPolynomials polys; // Allocate mem for each column for (auto& poly : polys.get_all()) { @@ -119,11 +119,11 @@ class AvmMiniCircuitBuilder { polys.avmMini_last[i] = rows[i].avmMini_last; } - polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); - polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); - polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); + polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); + polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); + polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); return polys; } @@ -161,14 +161,14 @@ class AvmMiniCircuitBuilder { return true; }; - if (!evaluate_relation.template operator()>( - "mem_trace", AvmMini_vm::get_relation_label_mem_trace)) { - return false; - } if (!evaluate_relation.template operator()>("avm_mini", AvmMini_vm::get_relation_label_avm_mini)) { return false; } + if (!evaluate_relation.template operator()>( + "mem_trace", AvmMini_vm::get_relation_label_mem_trace)) { + return false; + } return true; } diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/Toy_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/Toy_circuit_builder.hpp index fade5a864e99..3d52268a24fe 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/Toy_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/Toy_circuit_builder.hpp @@ -38,7 +38,7 @@ class ToyCircuitBuilder { // TODO: template using Polynomial = Flavor::Polynomial; - using AllPolynomials = Flavor::AllPolynomials; + using ProverPolynomials = Flavor::ProverPolynomials; static constexpr size_t num_fixed_columns = 9; static constexpr size_t num_polys = 8; @@ -46,10 +46,10 @@ class ToyCircuitBuilder { void set_trace(std::vector&& trace) { rows = std::move(trace); } - AllPolynomials compute_polynomials() + ProverPolynomials compute_polynomials() { const auto num_rows = get_circuit_subgroup_size(); - AllPolynomials polys; + ProverPolynomials polys; // Allocate mem for each column for (auto& poly : polys.get_all()) { @@ -91,7 +91,8 @@ class ToyCircuitBuilder { auto polys = compute_polynomials(); const size_t num_rows = polys.get_polynomial_size(); - const auto evaluate_relation = [&](const std::string& relation_name) { + const auto evaluate_relation = [&](const std::string& relation_name, + std::string (*debug_label)(int)) { typename Relation::SumcheckArrayOfValuesOverSubrelations result; for (auto& r : result) { r = 0; @@ -104,8 +105,9 @@ class ToyCircuitBuilder { bool x = true; for (size_t j = 0; j < NUM_SUBRELATIONS; ++j) { if (result[j] != 0) { + std::string row_name = debug_label(static_cast(j)); throw_or_abort( - format("Relation ", relation_name, ", subrelation index ", j, " failed at row ", i)); + format("Relation ", relation_name, ", subrelation index ", row_name, " failed at row ", i)); x = false; } } @@ -131,14 +133,15 @@ class ToyCircuitBuilder { } for (auto r : permutation_result) { if (r != 0) { - info("Tuple", permutation_name, "failed."); + info("Tuple ", permutation_name, " failed."); return false; } } return true; }; - if (!evaluate_relation.template operator()>("toy_avm")) { + if (!evaluate_relation.template operator()>("toy_avm", + Toy_vm::get_relation_label_toy_avm)) { return false; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp index 61f3f130d506..fdbe7b02d06a 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp @@ -7,30 +7,30 @@ namespace proof_system::AvmMini_vm { template struct Avm_miniRow { - FF avmMini_rwb{}; - FF avmMini_internal_return_ptr{}; - FF avmMini_mem_idx_a{}; + FF avmMini_pc{}; + FF avmMini_ib{}; FF avmMini_pc_shift{}; - FF avmMini_mem_op_b{}; - FF avmMini_sel_op_div{}; + FF avmMini_sel_op_sub{}; FF avmMini_sel_op_add{}; - FF avmMini_mem_op_a{}; - FF avmMini_internal_return_ptr_shift{}; - FF avmMini_ia{}; - FF avmMini_ic{}; - FF avmMini_ib{}; + FF avmMini_mem_idx_a{}; + FF avmMini_sel_halt{}; + FF avmMini_mem_op_c{}; FF avmMini_rwa{}; - FF avmMini_sel_internal_call{}; - FF avmMini_sel_op_sub{}; - FF avmMini_sel_op_mul{}; FF avmMini_op_err{}; + FF avmMini_ic{}; + FF avmMini_mem_op_a{}; + FF avmMini_ia{}; FF avmMini_sel_internal_return{}; - FF avmMini_sel_halt{}; - FF avmMini_pc{}; - FF avmMini_mem_op_c{}; + FF avmMini_sel_op_div{}; FF avmMini_first{}; + FF avmMini_internal_return_ptr_shift{}; FF avmMini_rwc{}; + FF avmMini_mem_op_b{}; + FF avmMini_rwb{}; + FF avmMini_internal_return_ptr{}; FF avmMini_inv{}; + FF avmMini_sel_op_mul{}; + FF avmMini_sel_internal_call{}; }; inline std::string get_relation_label_avm_mini(int index) @@ -38,6 +38,12 @@ inline std::string get_relation_label_avm_mini(int index) switch (index) { case 28: return "pc_increment"; + + case 18: + return "return_pointer_increment"; + + case 23: + return "return_pointer_decrement"; } return std::to_string(index); } @@ -47,7 +53,7 @@ template class avm_miniImpl { using FF = FF_; static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, }; template @@ -238,7 +244,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(22); - auto tmp = (avmMini_sel_internal_call * (avmMini_pc_shift - avmMini_ia)); + auto tmp = (avmMini_sel_internal_call * (avmMini_pc - avmMini_ia)); tmp *= scaling_factor; std::get<22>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp index 643c7c9a3e05..fa090be6c878 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp @@ -34,8 +34,8 @@ [[maybe_unused]] auto avmMini_mem_idx_b = View(new_term.avmMini_mem_idx_b); \ [[maybe_unused]] auto avmMini_mem_idx_c = View(new_term.avmMini_mem_idx_c); \ [[maybe_unused]] auto avmMini_last = View(new_term.avmMini_last); \ + [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ + [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); \ [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ - [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ - [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ - [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); + [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp index 497224f9856a..33e3d23ae57a 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp @@ -7,15 +7,15 @@ namespace proof_system::AvmMini_vm { template struct Mem_traceRow { - FF memTrace_m_addr{}; + FF memTrace_m_rw_shift{}; FF avmMini_first{}; FF avmMini_last{}; - FF memTrace_m_rw_shift{}; + FF memTrace_m_lastAccess{}; FF memTrace_m_rw{}; + FF memTrace_m_addr_shift{}; FF memTrace_m_val_shift{}; FF memTrace_m_val{}; - FF memTrace_m_lastAccess{}; - FF memTrace_m_addr_shift{}; + FF memTrace_m_addr{}; }; inline std::string get_relation_label_mem_trace(int index) diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/Toy/toy_avm.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/Toy/toy_avm.hpp index 40eb15cb6b3a..4364cb843ae0 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/Toy/toy_avm.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/Toy/toy_avm.hpp @@ -7,10 +7,16 @@ namespace proof_system::Toy_vm { template struct Toy_avmRow { - FF toy_x_shift{}; FF toy_x{}; + FF toy_x_shift{}; }; +inline std::string get_relation_label_toy_avm(int index) +{ + switch (index) {} + return std::to_string(index); +} + template class toy_avmImpl { public: using FF = FF_; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp index 18459b837557..3493608cf754 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_composer.cpp @@ -17,38 +17,10 @@ void AvmMiniComposer::compute_witness(CircuitConstructor& circuit) auto polynomials = circuit.compute_polynomials(); - proving_key->avmMini_clk = polynomials.avmMini_clk; - proving_key->avmMini_first = polynomials.avmMini_first; - proving_key->memTrace_m_clk = polynomials.memTrace_m_clk; - proving_key->memTrace_m_sub_clk = polynomials.memTrace_m_sub_clk; - proving_key->memTrace_m_addr = polynomials.memTrace_m_addr; - proving_key->memTrace_m_val = polynomials.memTrace_m_val; - proving_key->memTrace_m_lastAccess = polynomials.memTrace_m_lastAccess; - proving_key->memTrace_m_rw = polynomials.memTrace_m_rw; - proving_key->avmMini_pc = polynomials.avmMini_pc; - proving_key->avmMini_internal_return_ptr = polynomials.avmMini_internal_return_ptr; - proving_key->avmMini_sel_internal_call = polynomials.avmMini_sel_internal_call; - proving_key->avmMini_sel_internal_return = polynomials.avmMini_sel_internal_return; - proving_key->avmMini_sel_halt = polynomials.avmMini_sel_halt; - proving_key->avmMini_sel_op_add = polynomials.avmMini_sel_op_add; - proving_key->avmMini_sel_op_sub = polynomials.avmMini_sel_op_sub; - proving_key->avmMini_sel_op_mul = polynomials.avmMini_sel_op_mul; - proving_key->avmMini_sel_op_div = polynomials.avmMini_sel_op_div; - proving_key->avmMini_op_err = polynomials.avmMini_op_err; - proving_key->avmMini_inv = polynomials.avmMini_inv; - proving_key->avmMini_ia = polynomials.avmMini_ia; - proving_key->avmMini_ib = polynomials.avmMini_ib; - proving_key->avmMini_ic = polynomials.avmMini_ic; - proving_key->avmMini_mem_op_a = polynomials.avmMini_mem_op_a; - proving_key->avmMini_mem_op_b = polynomials.avmMini_mem_op_b; - proving_key->avmMini_mem_op_c = polynomials.avmMini_mem_op_c; - proving_key->avmMini_rwa = polynomials.avmMini_rwa; - proving_key->avmMini_rwb = polynomials.avmMini_rwb; - proving_key->avmMini_rwc = polynomials.avmMini_rwc; - proving_key->avmMini_mem_idx_a = polynomials.avmMini_mem_idx_a; - proving_key->avmMini_mem_idx_b = polynomials.avmMini_mem_idx_b; - proving_key->avmMini_mem_idx_c = polynomials.avmMini_mem_idx_c; - proving_key->avmMini_last = polynomials.avmMini_last; + for (auto [key_poly, prover_poly] : zip_view(proving_key->get_all(), polynomials.get_unshifted())) { + ASSERT(flavor_get_label(*proving_key, key_poly) == flavor_get_label(polynomials, prover_poly)); + key_poly = prover_poly; + } computed_witness = true; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp index 0f092f5f4074..9a7d4cc632b6 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/AvmMini_prover.cpp @@ -29,58 +29,16 @@ AvmMiniProver::AvmMiniProver(std::shared_ptr input_key, : key(input_key) , commitment_key(commitment_key) { - // TODO: take every polynomial and assign it to the key!! - prover_polynomials.avmMini_clk = key->avmMini_clk; - prover_polynomials.avmMini_first = key->avmMini_first; - prover_polynomials.memTrace_m_clk = key->memTrace_m_clk; - prover_polynomials.memTrace_m_sub_clk = key->memTrace_m_sub_clk; - prover_polynomials.memTrace_m_addr = key->memTrace_m_addr; - prover_polynomials.memTrace_m_val = key->memTrace_m_val; - prover_polynomials.memTrace_m_lastAccess = key->memTrace_m_lastAccess; - prover_polynomials.memTrace_m_rw = key->memTrace_m_rw; - prover_polynomials.avmMini_pc = key->avmMini_pc; - prover_polynomials.avmMini_internal_return_ptr = key->avmMini_internal_return_ptr; - prover_polynomials.avmMini_sel_internal_call = key->avmMini_sel_internal_call; - prover_polynomials.avmMini_sel_internal_return = key->avmMini_sel_internal_return; - prover_polynomials.avmMini_sel_halt = key->avmMini_sel_halt; - prover_polynomials.avmMini_sel_op_add = key->avmMini_sel_op_add; - prover_polynomials.avmMini_sel_op_sub = key->avmMini_sel_op_sub; - prover_polynomials.avmMini_sel_op_mul = key->avmMini_sel_op_mul; - prover_polynomials.avmMini_sel_op_div = key->avmMini_sel_op_div; - prover_polynomials.avmMini_op_err = key->avmMini_op_err; - prover_polynomials.avmMini_inv = key->avmMini_inv; - prover_polynomials.avmMini_ia = key->avmMini_ia; - prover_polynomials.avmMini_ib = key->avmMini_ib; - prover_polynomials.avmMini_ic = key->avmMini_ic; - prover_polynomials.avmMini_mem_op_a = key->avmMini_mem_op_a; - prover_polynomials.avmMini_mem_op_b = key->avmMini_mem_op_b; - prover_polynomials.avmMini_mem_op_c = key->avmMini_mem_op_c; - prover_polynomials.avmMini_rwa = key->avmMini_rwa; - prover_polynomials.avmMini_rwb = key->avmMini_rwb; - prover_polynomials.avmMini_rwc = key->avmMini_rwc; - prover_polynomials.avmMini_mem_idx_a = key->avmMini_mem_idx_a; - prover_polynomials.avmMini_mem_idx_b = key->avmMini_mem_idx_b; - prover_polynomials.avmMini_mem_idx_c = key->avmMini_mem_idx_c; - prover_polynomials.avmMini_last = key->avmMini_last; - - prover_polynomials.memTrace_m_rw = key->memTrace_m_rw; - prover_polynomials.memTrace_m_rw_shift = key->memTrace_m_rw.shifted(); - - prover_polynomials.memTrace_m_val = key->memTrace_m_val; - prover_polynomials.memTrace_m_val_shift = key->memTrace_m_val.shifted(); - - prover_polynomials.memTrace_m_addr = key->memTrace_m_addr; - prover_polynomials.memTrace_m_addr_shift = key->memTrace_m_addr.shifted(); - - prover_polynomials.avmMini_pc = key->avmMini_pc; - prover_polynomials.avmMini_pc_shift = key->avmMini_pc.shifted(); - - prover_polynomials.avmMini_internal_return_ptr = key->avmMini_internal_return_ptr; - prover_polynomials.avmMini_internal_return_ptr_shift = key->avmMini_internal_return_ptr.shifted(); - - // prover_polynomials.lookup_inverses = key->lookup_inverses; - // key->z_perm = Polynomial(key->circuit_size); - // prover_polynomials.z_perm = key->z_perm; + for (auto [prover_poly, key_poly] : zip_view(prover_polynomials.get_unshifted(), key->get_all())) { + ASSERT(proof_system::flavor_get_label(prover_polynomials, prover_poly) == + proof_system::flavor_get_label(*key, key_poly)); + prover_poly = key_poly.share(); + } + for (auto [prover_poly, key_poly] : zip_view(prover_polynomials.get_shifted(), key->get_to_be_shifted())) { + ASSERT(proof_system::flavor_get_label(prover_polynomials, prover_poly) == + proof_system::flavor_get_label(*key, key_poly) + "_shift"); + prover_poly = key_poly.shifted(); + } } /** diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/Toy_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/Toy_composer.cpp index 4d2ec73e1181..c74903fb6353 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/Toy_composer.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/Toy_composer.cpp @@ -17,14 +17,10 @@ void ToyComposer::compute_witness(CircuitConstructor& circuit) auto polynomials = circuit.compute_polynomials(); - proving_key->toy_first = polynomials.toy_first; - proving_key->toy_q_tuple_set = polynomials.toy_q_tuple_set; - proving_key->toy_set_1_column_1 = polynomials.toy_set_1_column_1; - proving_key->toy_set_1_column_2 = polynomials.toy_set_1_column_2; - proving_key->toy_set_2_column_1 = polynomials.toy_set_2_column_1; - proving_key->toy_set_2_column_2 = polynomials.toy_set_2_column_2; - proving_key->toy_x = polynomials.toy_x; - proving_key->two_column_perm = polynomials.two_column_perm; + for (auto [key_poly, prover_poly] : zip_view(proving_key->get_all(), polynomials.get_unshifted())) { + ASSERT(flavor_get_label(*proving_key, key_poly) == flavor_get_label(polynomials, prover_poly)); + key_poly = prover_poly; + } computed_witness = true; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/Toy_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/Toy_prover.cpp index 3d7738d13ef2..a29c274d1e49 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/Toy_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/Toy_prover.cpp @@ -28,22 +28,16 @@ ToyProver::ToyProver(std::shared_ptr input_key, std::shared_ : key(input_key) , commitment_key(commitment_key) { - // TODO: take every polynomial and assign it to the key!! - prover_polynomials.toy_first = key->toy_first; - prover_polynomials.toy_q_tuple_set = key->toy_q_tuple_set; - prover_polynomials.toy_set_1_column_1 = key->toy_set_1_column_1; - prover_polynomials.toy_set_1_column_2 = key->toy_set_1_column_2; - prover_polynomials.toy_set_2_column_1 = key->toy_set_2_column_1; - prover_polynomials.toy_set_2_column_2 = key->toy_set_2_column_2; - prover_polynomials.toy_x = key->toy_x; - prover_polynomials.two_column_perm = key->two_column_perm; - - prover_polynomials.toy_x = key->toy_x; - prover_polynomials.toy_x_shift = key->toy_x.shifted(); - - // prover_polynomials.lookup_inverses = key->lookup_inverses; - // key->z_perm = Polynomial(key->circuit_size); - // prover_polynomials.z_perm = key->z_perm; + for (auto [prover_poly, key_poly] : zip_view(prover_polynomials.get_unshifted(), key->get_all())) { + ASSERT(proof_system::flavor_get_label(prover_polynomials, prover_poly) == + proof_system::flavor_get_label(*key, key_poly)); + prover_poly = key_poly.share(); + } + for (auto [prover_poly, key_poly] : zip_view(prover_polynomials.get_shifted(), key->get_to_be_shifted())) { + ASSERT(proof_system::flavor_get_label(prover_polynomials, prover_poly) == + proof_system::flavor_get_label(*key, key_poly) + "_shift"); + prover_poly = key_poly.shifted(); + } } /** diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp new file mode 100644 index 000000000000..bfcbb776f0ae --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp @@ -0,0 +1,506 @@ +#include "barretenberg/ecc/curves/bn254/fr.hpp" +#include "barretenberg/flavor/generated/AvmMini_flavor.hpp" +#include "barretenberg/numeric/uint256/uint256.hpp" +#include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" +#include "barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp" +#include "barretenberg/sumcheck/sumcheck_round.hpp" +#include "barretenberg/vm/generated/AvmMini_composer.hpp" +#include "barretenberg/vm/generated/AvmMini_prover.hpp" +#include "barretenberg/vm/generated/AvmMini_verifier.hpp" + +#include +#include +#include +#include +#include + +using namespace proof_system; + +namespace tests_avm { + +class AvmMiniControlFlowTests : public ::testing::Test { + public: + AvmMiniTraceBuilder trace_builder; + + protected: + // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test. + void SetUp() override + { + barretenberg::srs::init_crs_factory("../srs_db/ignition"); + trace_builder = AvmMiniTraceBuilder(); // Clean instance for every run. + }; +}; + +class AvmMiniArithmeticNegativeTests : public AvmMiniControlFlowTests {}; + +// We add some helper functions in the anonymous namespace. +namespace { + +/** + * @brief Helper routine proving and verifying a proof based on the supplied trace + * + * @param trace The execution trace + */ +void validateTraceProof(std::vector&& trace) +{ + auto circuit_builder = AvmMiniCircuitBuilder(); + circuit_builder.set_trace(std::move(trace)); + + EXPECT_TRUE(circuit_builder.check_circuit()); + + auto composer = honk::AvmMiniComposer(); + auto prover = composer.create_prover(circuit_builder); + auto proof = prover.construct_proof(); + + auto verifier = composer.create_verifier(circuit_builder); + bool verified = verifier.verify_proof(proof); + + if (!verified) { + log_avmMini_trace(circuit_builder.rows, 0, 10); + } +}; + +// /** +// * @brief Helper routine for the negative tests. It mutates the output value of an operation +// * located in the Ic intermediate register. The memory trace is adapted consistently. +// * +// * @param trace Execution trace +// * @param selectRow Lambda serving to select the row in trace +// * @param newValue The value that will be written in intermediate register Ic at the selected row. +// */ +// void mutateIcInTrace(std::vector& trace, std::function&& selectRow, FF const& newValue) +// { +// // Find the first row matching the criteria defined by selectRow +// auto row = std::ranges::find_if(trace.begin(), trace.end(), selectRow); + +// // Check that we found one +// EXPECT_TRUE(row != trace.end()); + +// // Mutate the correct result in the main trace +// row->avmMini_ic = newValue; + +// // Adapt the memory trace to be consistent with the wrongly computed addition +// auto const clk = row->avmMini_clk; +// auto const addr = row->avmMini_mem_idx_c; + +// // Find the relevant memory trace entry. +// auto memRow = std::ranges::find_if(trace.begin(), trace.end(), [clk, addr](Row r) { +// return r.memTrace_m_clk == clk && r.memTrace_m_addr == addr; +// }); + +// EXPECT_TRUE(memRow != trace.end()); +// memRow->memTrace_m_val = newValue; +// }; + +} // anonymous namespace + +/****************************************************************************** + * + * POSITIVE TESTS - Finite Field Type + * + ****************************************************************************** + * The positive tests aim at testing that a genuinely generated execution trace + * is correct, i.e., the evaluation is correct and the proof passes. + * Positive refers to the proof system and not that the arithmetic operation has valid + * operands. A division by zero needs to be handled by the AVM and needs to raise an error. + * This will be positively tested, i.e., that the error is correctly raised. + * + * We isolate each operation addition, subtraction, multiplication and division + * by having dedicated unit test for each of them. + * In any positive test, we also verify that the main trace contains + * a write memory operation for the intermediate register Ic at the + * correct address. This operation belongs to the same row as the arithmetic + * operation. + * + * Finding the row pertaining to the arithmetic operation is done through + * a scan of all rows and stopping at the first one with the corresponding + * operator selector. This mechanism is used with the hope that these unit tests + * will still correctly work along the development of the AVM. + ******************************************************************************/ + +// Test on basic addition over finite field type. +TEST_F(AvmMiniControlFlowTests, simpleCall) +{ + // trace_builder for the following operation + // pc opcode + // 0 INTERNAL_CALL(pc=4) + // 4 HALT + trace_builder.internal_call(4); + trace_builder.halt(); + + auto trace = trace_builder.finalize(); + + info("Built circuit with ", trace.size(), " rows"); + + // Find the row of the call + auto call_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_call == FF(1); }); + EXPECT_TRUE(call_row != trace.end()); + EXPECT_EQ(call_row->avmMini_pc, FF(0)); + EXPECT_EQ(call_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); + EXPECT_EQ(call_row->avmMini_ia, FF(0)); + EXPECT_EQ(call_row->avmMini_mem_idx_a, + FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); // Store the return address (0) in memory + + // Find the row of the halt + auto halt_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_halt == FF(1); }); + + // Check that the correct result is stored at the expected memory location. + EXPECT_TRUE(halt_row != trace.end()); + EXPECT_EQ(halt_row->avmMini_pc, FF(4)); + EXPECT_EQ(halt_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); + + validateTraceProof(std::move(trace)); +} + +// // Test on basic subtraction over finite field type. +// TEST_F(AvmMiniControlFlowTests, subtractionFF) +// { +// trace_builder.callDataCopy(0, 3, 0, std::vector{ 8, 4, 17 }); + +// // Memory layout: [8,4,17,0,0,0,....] +// trace_builder.sub(2, 0, 1); // [8,9,17,0,0,0....] +// trace_builder.returnOP(0, 3); +// auto trace = trace_builder.finalize(); + +// // Find the first row enabling the subtraction selector +// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_sub == FF(1); }); + +// // Check that the correct result is stored at the expected memory location. +// EXPECT_TRUE(row != trace.end()); +// EXPECT_EQ(row->avmMini_ic, FF(9)); +// EXPECT_EQ(row->avmMini_mem_idx_c, FF(1)); +// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); +// EXPECT_EQ(row->avmMini_rwc, FF(1)); + +// validateTraceProof(std::move(trace)); +// } + +// // Test on basic multiplication over finite field type. +// TEST_F(AvmMiniControlFlowTests, multiplicationFF) +// { +// trace_builder.callDataCopy(0, 3, 0, std::vector{ 5, 0, 20 }); + +// // Memory layout: [5,0,20,0,0,0,....] +// trace_builder.mul(2, 0, 1); // [5,100,20,0,0,0....] +// trace_builder.returnOP(0, 3); +// auto trace = trace_builder.finalize(); + +// // Find the first row enabling the multiplication selector +// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_mul == FF(1); }); + +// // Check that the correct result is stored at the expected memory location. +// EXPECT_TRUE(row != trace.end()); +// EXPECT_EQ(row->avmMini_ic, FF(100)); +// EXPECT_EQ(row->avmMini_mem_idx_c, FF(1)); +// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); +// EXPECT_EQ(row->avmMini_rwc, FF(1)); + +// validateTraceProof(std::move(trace)); +// } + +// // Test on multiplication by zero over finite field type. +// TEST_F(AvmMiniControlFlowTests, multiplicationByZeroFF) +// { +// trace_builder.callDataCopy(0, 1, 0, std::vector{ 127 }); + +// // Memory layout: [127,0,0,0,0,0,....] +// trace_builder.mul(0, 1, 2); // [127,0,0,0,0,0....] +// trace_builder.returnOP(0, 3); +// auto trace = trace_builder.finalize(); + +// // Find the first row enabling the multiplication selector +// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_mul == FF(1); }); + +// // Check that the correct result is stored at the expected memory location. +// EXPECT_TRUE(row != trace.end()); +// EXPECT_EQ(row->avmMini_ic, FF(0)); +// EXPECT_EQ(row->avmMini_mem_idx_c, FF(2)); +// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); +// EXPECT_EQ(row->avmMini_rwc, FF(1)); + +// validateTraceProof(std::move(trace)); +// } + +// // Test on basic division over finite field type. +// TEST_F(AvmMiniControlFlowTests, divisionFF) +// { +// trace_builder.callDataCopy(0, 2, 0, std::vector{ 15, 315 }); + +// // Memory layout: [15,315,0,0,0,0,....] +// trace_builder.div(1, 0, 2); // [15,315,21,0,0,0....] +// trace_builder.returnOP(0, 3); +// auto trace = trace_builder.finalize(); + +// // Find the first row enabling the division selector +// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); + +// // Check that the correct result is stored at the expected memory location. +// EXPECT_TRUE(row != trace.end()); +// EXPECT_EQ(row->avmMini_ic, FF(21)); +// EXPECT_EQ(row->avmMini_mem_idx_c, FF(2)); +// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); +// EXPECT_EQ(row->avmMini_rwc, FF(1)); + +// validateTraceProof(std::move(trace)); +// } + +// // Test on division with zero numerator over finite field type. +// TEST_F(AvmMiniControlFlowTests, divisionNumeratorZeroFF) +// { +// trace_builder.callDataCopy(0, 1, 0, std::vector{ 15 }); + +// // Memory layout: [15,0,0,0,0,0,....] +// trace_builder.div(1, 0, 0); // [0,0,0,0,0,0....] +// trace_builder.returnOP(0, 3); +// auto trace = trace_builder.finalize(); + +// // Find the first row enabling the division selector +// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); + +// // Check that the correct result is stored at the expected memory location. +// EXPECT_TRUE(row != trace.end()); +// EXPECT_EQ(row->avmMini_ic, FF(0)); +// EXPECT_EQ(row->avmMini_mem_idx_c, FF(0)); +// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); +// EXPECT_EQ(row->avmMini_rwc, FF(1)); + +// validateTraceProof(std::move(trace)); +// } + +// // Test on division by zero over finite field type. +// // We check that the operator error flag is raised. +// TEST_F(AvmMiniControlFlowTests, divisionByZeroErrorFF) +// { +// trace_builder.callDataCopy(0, 1, 0, std::vector{ 15 }); + +// // Memory layout: [15,0,0,0,0,0,....] +// trace_builder.div(0, 1, 2); // [15,0,0,0,0,0....] +// trace_builder.halt(); +// auto trace = trace_builder.finalize(); + +// // Find the first row enabling the division selector +// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); + +// // Check that the correct result is stored at the expected memory location. +// EXPECT_TRUE(row != trace.end()); +// EXPECT_EQ(row->avmMini_ic, FF(0)); +// EXPECT_EQ(row->avmMini_mem_idx_c, FF(2)); +// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); +// EXPECT_EQ(row->avmMini_rwc, FF(1)); +// EXPECT_EQ(row->avmMini_op_err, FF(1)); + +// validateTraceProof(std::move(trace)); +// } + +// // Testing an execution of the different arithmetic opcodes over finite field +// // and finishing with a division by zero. The chosen combination is arbitrary. +// // We only test that the proof can be correctly generated and verified. +// // No check on the evaluation is performed here. +// TEST_F(AvmMiniControlFlowTests, arithmeticFFWithError) +// { +// trace_builder.callDataCopy(0, 3, 2, std::vector{ 45, 23, 12 }); + +// // Memory layout: [0,0,45,23,12,0,0,0,....] +// trace_builder.add(2, 3, 4); // [0,0,45,23,68,0,0,0,....] +// trace_builder.add(4, 5, 5); // [0,0,45,23,68,68,0,0,....] +// trace_builder.add(5, 5, 5); // [0,0,45,23,68,136,0,0,....] +// trace_builder.add(5, 6, 7); // [0,0,45,23,68,136,0,136,0....] +// trace_builder.sub(7, 6, 8); // [0,0,45,23,68,136,0,136,136,0....] +// trace_builder.mul(8, 8, 8); // [0,0,45,23,68,136,0,136,136^2,0....] +// trace_builder.div(3, 5, 1); // [0,23*136^(-1),45,23,68,136,0,136,136^2,0....] +// trace_builder.div(1, 1, 9); // [0,23*136^(-1),45,23,68,136,0,136,136^2,1,0....] +// trace_builder.div(9, 0, 4); // [0,23*136^(-1),45,23,1/0,136,0,136,136^2,1,0....] Error: division by 0 +// trace_builder.halt(); + +// auto trace = trace_builder.finalize(); +// validateTraceProof(std::move(trace)); +// } + +// /****************************************************************************** +// * +// * NEGATIVE TESTS - Finite Field Type +// * +// ****************************************************************************** +// * The negative tests are the counterparts of the positive tests for which we want +// * to test that a deviation of the prescribed behaviour of the VM will lead to +// * an exception being raised while attempting to generate a proof. +// * +// * As for the positive tests, we isolate each operation addition, subtraction, multiplication +// * and division by having dedicated unit test for each of them. +// * A typical pattern is to wrongly mutate the result of the operation. The memory trace +// * is consistently adapted so that the negative test is applying to the relation +// * if the arithmetic operation and not the layout of the memory trace. +// * +// * Finding the row pertaining to the arithmetic operation is done through +// * a scan of all rows and stopping at the first one with the corresponding +// * operator selector. This mechanism is used with the hope that these unit tests +// * will still correctly work along the development of the AVM. +// ******************************************************************************/ + +// // Test on basic incorrect addition over finite field type. +// TEST_F(AvmMiniArithmeticNegativeTests, additionFF) +// { +// trace_builder.callDataCopy(0, 3, 0, std::vector{ 37, 4, 11 }); + +// // Memory layout: [37,4,11,0,0,0,....] +// trace_builder.add(0, 1, 4); // [37,4,11,0,41,0,....] +// trace_builder.returnOP(0, 5); +// auto trace = trace_builder.finalize(); + +// auto selectRow = [](Row r) { return r.avmMini_sel_op_add == FF(1); }; +// mutateIcInTrace(trace, std::move(selectRow), FF(40)); + +// // TODO: check that the expected sub-relation failed +// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); +// } + +// // Test on basic incorrect subtraction over finite field type. +// TEST_F(AvmMiniArithmeticNegativeTests, subtractionFF) +// { +// trace_builder.callDataCopy(0, 3, 0, std::vector{ 8, 4, 17 }); + +// // Memory layout: [8,4,17,0,0,0,....] +// trace_builder.sub(2, 0, 1); // [8,9,17,0,0,0....] +// trace_builder.returnOP(0, 3); +// auto trace = trace_builder.finalize(); + +// auto selectRow = [](Row r) { return r.avmMini_sel_op_sub == FF(1); }; +// mutateIcInTrace(trace, std::move(selectRow), FF(-9)); + +// // TODO: check that the expected sub-relation failed +// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); +// } + +// // Test on basic incorrect multiplication over finite field type. +// TEST_F(AvmMiniArithmeticNegativeTests, multiplicationFF) +// { +// trace_builder.callDataCopy(0, 3, 0, std::vector{ 5, 0, 20 }); + +// // Memory layout: [5,0,20,0,0,0,....] +// trace_builder.mul(2, 0, 1); // [5,100,20,0,0,0....] +// trace_builder.returnOP(0, 3); +// auto trace = trace_builder.finalize(); + +// auto selectRow = [](Row r) { return r.avmMini_sel_op_mul == FF(1); }; +// mutateIcInTrace(trace, std::move(selectRow), FF(1000)); + +// // TODO: check that the expected sub-relation failed +// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); +// } + +// // Test on basic incorrect division over finite field type. +// TEST_F(AvmMiniArithmeticNegativeTests, divisionFF) +// { +// trace_builder.callDataCopy(0, 2, 0, std::vector{ 15, 315 }); + +// // Memory layout: [15,315,0,0,0,0,....] +// trace_builder.div(1, 0, 2); // [15,315,21,0,0,0....] +// trace_builder.returnOP(0, 3); +// auto trace = trace_builder.finalize(); + +// auto selectRow = [](Row r) { return r.avmMini_sel_op_div == FF(1); }; +// mutateIcInTrace(trace, std::move(selectRow), FF(0)); + +// // TODO: check that the expected sub-relation failed +// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); +// } + +// // Test where division is not by zero but an operation error is wrongly raised +// // in the trace. +// TEST_F(AvmMiniArithmeticNegativeTests, divisionNoZeroButErrorFF) +// { +// trace_builder.callDataCopy(0, 2, 0, std::vector{ 15, 315 }); + +// // Memory layout: [15,315,0,0,0,0,....] +// trace_builder.div(1, 0, 2); // [15,315,21,0,0,0....] +// trace_builder.returnOP(0, 3); +// auto trace = trace_builder.finalize(); + +// // Find the first row enabling the division selector +// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); + +// // Activate the operator error +// row->avmMini_op_err = FF(1); + +// // TODO: check that the expected sub-relation failed +// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); +// } + +// // Test with division by zero occurs and no error is raised (remove error flag) +// TEST_F(AvmMiniArithmeticNegativeTests, divisionByZeroNoErrorFF) +// { +// trace_builder.callDataCopy(0, 1, 0, std::vector{ 15 }); + +// // Memory layout: [15,0,0,0,0,0,....] +// trace_builder.div(0, 1, 2); // [15,0,0,0,0,0....] +// auto trace = trace_builder.finalize(); + +// // Find the first row enabling the division selector +// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); + +// // Remove the operator error flag +// row->avmMini_op_err = FF(0); + +// // TODO: check that the expected sub-relation failed +// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); +// } + +// // Test that error flag cannot be raised for a non-relevant operation such as +// // the addition, subtraction, multiplication. +// TEST_F(AvmMiniArithmeticNegativeTests, operationWithErrorFlagFF) +// { +// trace_builder.callDataCopy(0, 3, 0, std::vector{ 37, 4, 11 }); + +// // Memory layout: [37,4,11,0,0,0,....] +// trace_builder.add(0, 1, 4); // [37,4,11,0,41,0,....] +// trace_builder.returnOP(0, 5); +// auto trace = trace_builder.finalize(); + +// // Find the first row enabling the addition selector +// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_add == FF(1); }); + +// // Activate the operator error +// row->avmMini_op_err = FF(1); + +// // TODO: check that the expected sub-relation failed +// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); + +// trace_builder.reset(); + +// trace_builder.callDataCopy(0, 3, 0, std::vector{ 8, 4, 17 }); + +// // Memory layout: [8,4,17,0,0,0,....] +// trace_builder.sub(2, 0, 1); // [8,9,17,0,0,0....] +// trace_builder.returnOP(0, 3); +// trace = trace_builder.finalize(); + +// // Find the first row enabling the subtraction selector +// row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_sub == FF(1); }); + +// // Activate the operator error +// row->avmMini_op_err = FF(1); + +// // TODO: check that the expected sub-relation failed +// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); + +// trace_builder.reset(); + +// trace_builder.callDataCopy(0, 3, 0, std::vector{ 5, 0, 20 }); + +// // Memory layout: [5,0,20,0,0,0,....] +// trace_builder.mul(2, 0, 1); // [5,100,20,0,0,0....] +// trace_builder.returnOP(0, 3); +// trace = trace_builder.finalize(); + +// // Find the first row enabling the multiplication selector +// row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_mul == FF(1); }); + +// // Activate the operator error +// row->avmMini_op_err = FF(1); + +// // TODO: check that the expected sub-relation failed +// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); +// } + +} // namespace tests_avm \ No newline at end of file From 64b5f10a658742b6626cb14b16955b194389f51c Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 18 Dec 2023 22:16:13 +0000 Subject: [PATCH 05/10] feat: add tests --- barretenberg/cpp/pil/avm/avm_mini.pil | 6 +- .../flavor/generated/AvmMini_flavor.hpp | 31 +- .../circuit_builder/AvmMini_trace.cpp | 23 +- .../generated/AvmMini_circuit_builder.hpp | 23 +- .../relations/generated/AvmMini/avm_mini.hpp | 49 +- .../generated/AvmMini/declare_views.hpp | 8 +- .../relations/generated/AvmMini/mem_trace.hpp | 12 +- .../vm/tests/AvmMini_control_flow.test.cpp | 538 +++++------------- 8 files changed, 232 insertions(+), 458 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index 9ff602122a94..94a05cd52bf5 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -137,14 +137,14 @@ namespace avmMini(256); // We must load the memory pointer to be the internal_return_ptr #[return_pointer_decrement] sel_internal_return * ( internal_return_ptr' - ( internal_return_ptr - 1)) = 0; // We decrement out jump selector - sel_internal_return * ( internal_return_ptr - mem_idx_a) = 0; - sel_internal_return * (pc' - ia) = 0; + sel_internal_return * ( (internal_return_ptr - 1) - mem_idx_a) = 0; + sel_internal_return * (pc' - (ia+1)) = 0; sel_internal_return * rwa = 0; sel_internal_return * (mem_op_a - 1) = 0; // Program counter must increment if not jumping or returning #[pc_increment] - (1-first) * (1- sel_halt) * (sel_internal_call + sel_internal_return + sel_op_add + sel_op_sub + sel_op_div + sel_op_mul) * (pc' - (pc + 1)) = 0; + (1-first) * (1- sel_halt) * (sel_op_add + sel_op_sub + sel_op_div + sel_op_mul) * (pc' - (pc + 1)) = 0; // TODO: we want to set an initial number for the reserved memory of the jump pointer diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp index 32b111d800e9..26d8869e8a2b 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp @@ -42,7 +42,7 @@ class AvmMiniFlavor { // the unshifted and one for the shifted static constexpr size_t NUM_ALL_ENTITIES = 37; - using Relations = std::tuple, AvmMini_vm::mem_trace>; + using Relations = std::tuple, AvmMini_vm::avm_mini>; static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); @@ -178,11 +178,11 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, - avmMini_pc_shift, - avmMini_internal_return_ptr_shift, - memTrace_m_rw_shift, memTrace_m_addr_shift, - memTrace_m_val_shift) + memTrace_m_rw_shift, + memTrace_m_val_shift, + avmMini_pc_shift, + avmMini_internal_return_ptr_shift) RefVector get_wires() { @@ -218,11 +218,11 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, - avmMini_pc_shift, - avmMini_internal_return_ptr_shift, - memTrace_m_rw_shift, memTrace_m_addr_shift, - memTrace_m_val_shift }; + memTrace_m_rw_shift, + memTrace_m_val_shift, + avmMini_pc_shift, + avmMini_internal_return_ptr_shift }; }; RefVector get_unshifted() { @@ -261,15 +261,15 @@ class AvmMiniFlavor { }; RefVector get_to_be_shifted() { - return { avmMini_pc, avmMini_internal_return_ptr, memTrace_m_rw, memTrace_m_addr, memTrace_m_val }; + return { memTrace_m_addr, memTrace_m_rw, memTrace_m_val, avmMini_pc, avmMini_internal_return_ptr }; }; RefVector get_shifted() { - return { avmMini_pc_shift, - avmMini_internal_return_ptr_shift, + return { memTrace_m_addr_shift, memTrace_m_rw_shift, - memTrace_m_addr_shift, - memTrace_m_val_shift }; + memTrace_m_val_shift, + avmMini_pc_shift, + avmMini_internal_return_ptr_shift }; }; }; @@ -282,7 +282,7 @@ class AvmMiniFlavor { RefVector get_to_be_shifted() { - return { avmMini_pc, avmMini_internal_return_ptr, memTrace_m_rw, memTrace_m_addr, memTrace_m_val }; + return { memTrace_m_addr, memTrace_m_rw, memTrace_m_val, avmMini_pc, avmMini_internal_return_ptr }; }; // The plookup wires that store plookup read data. @@ -325,6 +325,7 @@ class AvmMiniFlavor { return result; } }; + using RowPolynomials = AllEntities; class PartiallyEvaluatedMultivariates : public AllEntities { diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index 2f69ccd6ae1b..0fcb21d62e2f 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -541,6 +541,7 @@ void AvmMiniTraceBuilder::halt() auto clk = mainTrace.size(); info("pc at halt: ", pc); + info("return pointer at halt: ", internal_return_ptr); mainTrace.push_back(Row{ .avmMini_clk = clk, @@ -573,19 +574,23 @@ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) }); // We want the next row to be the one pointed by jmpDest + ffMemory.at(internal_return_ptr) = pc; pc = jmpDest; - internal_return_ptr++; + this->internal_return_ptr++; } void AvmMiniTraceBuilder::internal_return() { auto clk = mainTrace.size(); - // TODO: make sure this is initialized - FF a = ffMemory.at(internal_return_ptr); + // Internal return pointer is decremented + FF a = ffMemory.at(internal_return_ptr - 1); - // We want to write the current pc to the memory location pointed by - storeAInMemTrace(internal_return_ptr, FF(pc)); + info("The internal pointer ", internal_return_ptr); + info("The internal pointer value", a); + + // We want to load the value pointed by the internal pointer + loadAInMemTrace(internal_return_ptr - 1, FF(a)); mainTrace.push_back(Row{ .avmMini_clk = clk, @@ -595,17 +600,15 @@ void AvmMiniTraceBuilder::internal_return() .avmMini_ia = a, .avmMini_mem_op_a = FF(1), .avmMini_rwa = FF(0), - .avmMini_mem_idx_a = FF(internal_return_ptr), + .avmMini_mem_idx_a = FF(internal_return_ptr - 1), }); // We want the next row to be the one pointed by jmpDest // TODO: is this type casting safe - // The next pc should be from the top of the internal call stack - pc = internal_call_stack.top(); + // The next pc should be from the top of the internal call stack + 1 + pc = internal_call_stack.top() + 1; internal_call_stack.pop(); - - // The internal call stack pointer should be decremented internal_return_ptr--; } diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp index f70c6f85409a..d86b27eba0ba 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp @@ -51,11 +51,11 @@ template struct AvmMiniFullRow { FF avmMini_mem_idx_b{}; FF avmMini_mem_idx_c{}; FF avmMini_last{}; - FF avmMini_pc_shift{}; - FF avmMini_internal_return_ptr_shift{}; - FF memTrace_m_rw_shift{}; FF memTrace_m_addr_shift{}; + FF memTrace_m_rw_shift{}; FF memTrace_m_val_shift{}; + FF avmMini_pc_shift{}; + FF avmMini_internal_return_ptr_shift{}; }; class AvmMiniCircuitBuilder { @@ -119,18 +119,19 @@ class AvmMiniCircuitBuilder { polys.avmMini_last[i] = rows[i].avmMini_last; } - polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); - polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); - polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); + polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); + polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); + polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); return polys; } [[maybe_unused]] bool check_circuit() { - ProverPolynomials polys = compute_polynomials(); + + auto polys = compute_polynomials(); const size_t num_rows = polys.get_polynomial_size(); const auto evaluate_relation = [&](const std::string& relation_name, @@ -160,14 +161,14 @@ class AvmMiniCircuitBuilder { return true; }; - if (!evaluate_relation.template operator()>("avm_mini", - AvmMini_vm::get_relation_label_avm_mini)) { - return false; - } if (!evaluate_relation.template operator()>( "mem_trace", AvmMini_vm::get_relation_label_mem_trace)) { return false; } + if (!evaluate_relation.template operator()>("avm_mini", + AvmMini_vm::get_relation_label_avm_mini)) { + return false; + } return true; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp index fdbe7b02d06a..84fbc07be8c0 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp @@ -7,30 +7,30 @@ namespace proof_system::AvmMini_vm { template struct Avm_miniRow { - FF avmMini_pc{}; - FF avmMini_ib{}; FF avmMini_pc_shift{}; + FF avmMini_mem_op_b{}; + FF avmMini_mem_op_c{}; + FF avmMini_ib{}; + FF avmMini_mem_op_a{}; + FF avmMini_sel_internal_call{}; + FF avmMini_op_err{}; + FF avmMini_sel_op_div{}; FF avmMini_sel_op_sub{}; - FF avmMini_sel_op_add{}; + FF avmMini_sel_internal_return{}; + FF avmMini_rwb{}; + FF avmMini_sel_op_mul{}; + FF avmMini_ia{}; FF avmMini_mem_idx_a{}; FF avmMini_sel_halt{}; - FF avmMini_mem_op_c{}; - FF avmMini_rwa{}; - FF avmMini_op_err{}; + FF avmMini_inv{}; FF avmMini_ic{}; - FF avmMini_mem_op_a{}; - FF avmMini_ia{}; - FF avmMini_sel_internal_return{}; - FF avmMini_sel_op_div{}; - FF avmMini_first{}; - FF avmMini_internal_return_ptr_shift{}; + FF avmMini_sel_op_add{}; + FF avmMini_rwa{}; FF avmMini_rwc{}; - FF avmMini_mem_op_b{}; - FF avmMini_rwb{}; + FF avmMini_internal_return_ptr_shift{}; + FF avmMini_first{}; + FF avmMini_pc{}; FF avmMini_internal_return_ptr{}; - FF avmMini_inv{}; - FF avmMini_sel_op_mul{}; - FF avmMini_sel_internal_call{}; }; inline std::string get_relation_label_avm_mini(int index) @@ -39,11 +39,11 @@ inline std::string get_relation_label_avm_mini(int index) case 28: return "pc_increment"; - case 18: - return "return_pointer_increment"; - case 23: return "return_pointer_decrement"; + + case 18: + return "return_pointer_increment"; } return std::to_string(index); } @@ -261,7 +261,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(24); - auto tmp = (avmMini_sel_internal_return * (avmMini_internal_return_ptr - avmMini_mem_idx_a)); + auto tmp = (avmMini_sel_internal_return * ((avmMini_internal_return_ptr - FF(1)) - avmMini_mem_idx_a)); tmp *= scaling_factor; std::get<24>(evals) += tmp; } @@ -269,7 +269,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(25); - auto tmp = (avmMini_sel_internal_return * (avmMini_pc_shift - avmMini_ia)); + auto tmp = (avmMini_sel_internal_return * (avmMini_pc_shift - (avmMini_ia + FF(1)))); tmp *= scaling_factor; std::get<25>(evals) += tmp; } @@ -294,10 +294,7 @@ template class avm_miniImpl { AvmMini_DECLARE_VIEWS(28); auto tmp = ((((-avmMini_first + FF(1)) * (-avmMini_sel_halt + FF(1))) * - (((((avmMini_sel_internal_call + avmMini_sel_internal_return) + avmMini_sel_op_add) + - avmMini_sel_op_sub) + - avmMini_sel_op_div) + - avmMini_sel_op_mul)) * + (((avmMini_sel_op_add + avmMini_sel_op_sub) + avmMini_sel_op_div) + avmMini_sel_op_mul)) * (avmMini_pc_shift - (avmMini_pc + FF(1)))); tmp *= scaling_factor; std::get<28>(evals) += tmp; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp index fa090be6c878..f53f99371e16 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp @@ -34,8 +34,8 @@ [[maybe_unused]] auto avmMini_mem_idx_b = View(new_term.avmMini_mem_idx_b); \ [[maybe_unused]] auto avmMini_mem_idx_c = View(new_term.avmMini_mem_idx_c); \ [[maybe_unused]] auto avmMini_last = View(new_term.avmMini_last); \ - [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ - [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); \ - [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ - [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); + [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ + [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ + [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ + [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp index 33e3d23ae57a..b9e99924418c 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp @@ -7,15 +7,15 @@ namespace proof_system::AvmMini_vm { template struct Mem_traceRow { - FF memTrace_m_rw_shift{}; - FF avmMini_first{}; - FF avmMini_last{}; - FF memTrace_m_lastAccess{}; - FF memTrace_m_rw{}; FF memTrace_m_addr_shift{}; - FF memTrace_m_val_shift{}; + FF memTrace_m_rw{}; + FF avmMini_last{}; FF memTrace_m_val{}; + FF memTrace_m_lastAccess{}; + FF avmMini_first{}; FF memTrace_m_addr{}; + FF memTrace_m_rw_shift{}; + FF memTrace_m_val_shift{}; }; inline std::string get_relation_label_mem_trace(int index) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp index bfcbb776f0ae..5ea342911d81 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp @@ -59,73 +59,22 @@ void validateTraceProof(std::vector&& trace) log_avmMini_trace(circuit_builder.rows, 0, 10); } }; - -// /** -// * @brief Helper routine for the negative tests. It mutates the output value of an operation -// * located in the Ic intermediate register. The memory trace is adapted consistently. -// * -// * @param trace Execution trace -// * @param selectRow Lambda serving to select the row in trace -// * @param newValue The value that will be written in intermediate register Ic at the selected row. -// */ -// void mutateIcInTrace(std::vector& trace, std::function&& selectRow, FF const& newValue) -// { -// // Find the first row matching the criteria defined by selectRow -// auto row = std::ranges::find_if(trace.begin(), trace.end(), selectRow); - -// // Check that we found one -// EXPECT_TRUE(row != trace.end()); - -// // Mutate the correct result in the main trace -// row->avmMini_ic = newValue; - -// // Adapt the memory trace to be consistent with the wrongly computed addition -// auto const clk = row->avmMini_clk; -// auto const addr = row->avmMini_mem_idx_c; - -// // Find the relevant memory trace entry. -// auto memRow = std::ranges::find_if(trace.begin(), trace.end(), [clk, addr](Row r) { -// return r.memTrace_m_clk == clk && r.memTrace_m_addr == addr; -// }); - -// EXPECT_TRUE(memRow != trace.end()); -// memRow->memTrace_m_val = newValue; -// }; - } // anonymous namespace /****************************************************************************** * - * POSITIVE TESTS - Finite Field Type - * - ****************************************************************************** - * The positive tests aim at testing that a genuinely generated execution trace - * is correct, i.e., the evaluation is correct and the proof passes. - * Positive refers to the proof system and not that the arithmetic operation has valid - * operands. A division by zero needs to be handled by the AVM and needs to raise an error. - * This will be positively tested, i.e., that the error is correctly raised. - * - * We isolate each operation addition, subtraction, multiplication and division - * by having dedicated unit test for each of them. - * In any positive test, we also verify that the main trace contains - * a write memory operation for the intermediate register Ic at the - * correct address. This operation belongs to the same row as the arithmetic - * operation. + * POSITIVE TESTS - Control Flow * - * Finding the row pertaining to the arithmetic operation is done through - * a scan of all rows and stopping at the first one with the corresponding - * operator selector. This mechanism is used with the hope that these unit tests - * will still correctly work along the development of the AVM. - ******************************************************************************/ + *****************************************************************************/ -// Test on basic addition over finite field type. TEST_F(AvmMiniControlFlowTests, simpleCall) { + uint32_t const CALL_ADDRESS = 4; // trace_builder for the following operation // pc opcode // 0 INTERNAL_CALL(pc=4) // 4 HALT - trace_builder.internal_call(4); + trace_builder.internal_call(CALL_ADDRESS); trace_builder.halt(); auto trace = trace_builder.finalize(); @@ -147,360 +96,183 @@ TEST_F(AvmMiniControlFlowTests, simpleCall) // Check that the correct result is stored at the expected memory location. EXPECT_TRUE(halt_row != trace.end()); - EXPECT_EQ(halt_row->avmMini_pc, FF(4)); + EXPECT_EQ(halt_row->avmMini_pc, FF(CALL_ADDRESS)); EXPECT_EQ(halt_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); validateTraceProof(std::move(trace)); } -// // Test on basic subtraction over finite field type. -// TEST_F(AvmMiniControlFlowTests, subtractionFF) -// { -// trace_builder.callDataCopy(0, 3, 0, std::vector{ 8, 4, 17 }); - -// // Memory layout: [8,4,17,0,0,0,....] -// trace_builder.sub(2, 0, 1); // [8,9,17,0,0,0....] -// trace_builder.returnOP(0, 3); -// auto trace = trace_builder.finalize(); - -// // Find the first row enabling the subtraction selector -// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_sub == FF(1); }); - -// // Check that the correct result is stored at the expected memory location. -// EXPECT_TRUE(row != trace.end()); -// EXPECT_EQ(row->avmMini_ic, FF(9)); -// EXPECT_EQ(row->avmMini_mem_idx_c, FF(1)); -// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); -// EXPECT_EQ(row->avmMini_rwc, FF(1)); - -// validateTraceProof(std::move(trace)); -// } - -// // Test on basic multiplication over finite field type. -// TEST_F(AvmMiniControlFlowTests, multiplicationFF) -// { -// trace_builder.callDataCopy(0, 3, 0, std::vector{ 5, 0, 20 }); - -// // Memory layout: [5,0,20,0,0,0,....] -// trace_builder.mul(2, 0, 1); // [5,100,20,0,0,0....] -// trace_builder.returnOP(0, 3); -// auto trace = trace_builder.finalize(); - -// // Find the first row enabling the multiplication selector -// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_mul == FF(1); }); - -// // Check that the correct result is stored at the expected memory location. -// EXPECT_TRUE(row != trace.end()); -// EXPECT_EQ(row->avmMini_ic, FF(100)); -// EXPECT_EQ(row->avmMini_mem_idx_c, FF(1)); -// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); -// EXPECT_EQ(row->avmMini_rwc, FF(1)); - -// validateTraceProof(std::move(trace)); -// } - -// // Test on multiplication by zero over finite field type. -// TEST_F(AvmMiniControlFlowTests, multiplicationByZeroFF) -// { -// trace_builder.callDataCopy(0, 1, 0, std::vector{ 127 }); - -// // Memory layout: [127,0,0,0,0,0,....] -// trace_builder.mul(0, 1, 2); // [127,0,0,0,0,0....] -// trace_builder.returnOP(0, 3); -// auto trace = trace_builder.finalize(); - -// // Find the first row enabling the multiplication selector -// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_mul == FF(1); }); - -// // Check that the correct result is stored at the expected memory location. -// EXPECT_TRUE(row != trace.end()); -// EXPECT_EQ(row->avmMini_ic, FF(0)); -// EXPECT_EQ(row->avmMini_mem_idx_c, FF(2)); -// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); -// EXPECT_EQ(row->avmMini_rwc, FF(1)); - -// validateTraceProof(std::move(trace)); -// } - -// // Test on basic division over finite field type. -// TEST_F(AvmMiniControlFlowTests, divisionFF) -// { -// trace_builder.callDataCopy(0, 2, 0, std::vector{ 15, 315 }); - -// // Memory layout: [15,315,0,0,0,0,....] -// trace_builder.div(1, 0, 2); // [15,315,21,0,0,0....] -// trace_builder.returnOP(0, 3); -// auto trace = trace_builder.finalize(); - -// // Find the first row enabling the division selector -// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); - -// // Check that the correct result is stored at the expected memory location. -// EXPECT_TRUE(row != trace.end()); -// EXPECT_EQ(row->avmMini_ic, FF(21)); -// EXPECT_EQ(row->avmMini_mem_idx_c, FF(2)); -// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); -// EXPECT_EQ(row->avmMini_rwc, FF(1)); - -// validateTraceProof(std::move(trace)); -// } - -// // Test on division with zero numerator over finite field type. -// TEST_F(AvmMiniControlFlowTests, divisionNumeratorZeroFF) -// { -// trace_builder.callDataCopy(0, 1, 0, std::vector{ 15 }); - -// // Memory layout: [15,0,0,0,0,0,....] -// trace_builder.div(1, 0, 0); // [0,0,0,0,0,0....] -// trace_builder.returnOP(0, 3); -// auto trace = trace_builder.finalize(); - -// // Find the first row enabling the division selector -// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); - -// // Check that the correct result is stored at the expected memory location. -// EXPECT_TRUE(row != trace.end()); -// EXPECT_EQ(row->avmMini_ic, FF(0)); -// EXPECT_EQ(row->avmMini_mem_idx_c, FF(0)); -// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); -// EXPECT_EQ(row->avmMini_rwc, FF(1)); - -// validateTraceProof(std::move(trace)); -// } - -// // Test on division by zero over finite field type. -// // We check that the operator error flag is raised. -// TEST_F(AvmMiniControlFlowTests, divisionByZeroErrorFF) -// { -// trace_builder.callDataCopy(0, 1, 0, std::vector{ 15 }); - -// // Memory layout: [15,0,0,0,0,0,....] -// trace_builder.div(0, 1, 2); // [15,0,0,0,0,0....] -// trace_builder.halt(); -// auto trace = trace_builder.finalize(); - -// // Find the first row enabling the division selector -// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); - -// // Check that the correct result is stored at the expected memory location. -// EXPECT_TRUE(row != trace.end()); -// EXPECT_EQ(row->avmMini_ic, FF(0)); -// EXPECT_EQ(row->avmMini_mem_idx_c, FF(2)); -// EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); -// EXPECT_EQ(row->avmMini_rwc, FF(1)); -// EXPECT_EQ(row->avmMini_op_err, FF(1)); - -// validateTraceProof(std::move(trace)); -// } - -// // Testing an execution of the different arithmetic opcodes over finite field -// // and finishing with a division by zero. The chosen combination is arbitrary. -// // We only test that the proof can be correctly generated and verified. -// // No check on the evaluation is performed here. -// TEST_F(AvmMiniControlFlowTests, arithmeticFFWithError) -// { -// trace_builder.callDataCopy(0, 3, 2, std::vector{ 45, 23, 12 }); - -// // Memory layout: [0,0,45,23,12,0,0,0,....] -// trace_builder.add(2, 3, 4); // [0,0,45,23,68,0,0,0,....] -// trace_builder.add(4, 5, 5); // [0,0,45,23,68,68,0,0,....] -// trace_builder.add(5, 5, 5); // [0,0,45,23,68,136,0,0,....] -// trace_builder.add(5, 6, 7); // [0,0,45,23,68,136,0,136,0....] -// trace_builder.sub(7, 6, 8); // [0,0,45,23,68,136,0,136,136,0....] -// trace_builder.mul(8, 8, 8); // [0,0,45,23,68,136,0,136,136^2,0....] -// trace_builder.div(3, 5, 1); // [0,23*136^(-1),45,23,68,136,0,136,136^2,0....] -// trace_builder.div(1, 1, 9); // [0,23*136^(-1),45,23,68,136,0,136,136^2,1,0....] -// trace_builder.div(9, 0, 4); // [0,23*136^(-1),45,23,1/0,136,0,136,136^2,1,0....] Error: division by 0 -// trace_builder.halt(); - -// auto trace = trace_builder.finalize(); -// validateTraceProof(std::move(trace)); -// } - -// /****************************************************************************** -// * -// * NEGATIVE TESTS - Finite Field Type -// * -// ****************************************************************************** -// * The negative tests are the counterparts of the positive tests for which we want -// * to test that a deviation of the prescribed behaviour of the VM will lead to -// * an exception being raised while attempting to generate a proof. -// * -// * As for the positive tests, we isolate each operation addition, subtraction, multiplication -// * and division by having dedicated unit test for each of them. -// * A typical pattern is to wrongly mutate the result of the operation. The memory trace -// * is consistently adapted so that the negative test is applying to the relation -// * if the arithmetic operation and not the layout of the memory trace. -// * -// * Finding the row pertaining to the arithmetic operation is done through -// * a scan of all rows and stopping at the first one with the corresponding -// * operator selector. This mechanism is used with the hope that these unit tests -// * will still correctly work along the development of the AVM. -// ******************************************************************************/ - -// // Test on basic incorrect addition over finite field type. -// TEST_F(AvmMiniArithmeticNegativeTests, additionFF) -// { -// trace_builder.callDataCopy(0, 3, 0, std::vector{ 37, 4, 11 }); - -// // Memory layout: [37,4,11,0,0,0,....] -// trace_builder.add(0, 1, 4); // [37,4,11,0,41,0,....] -// trace_builder.returnOP(0, 5); -// auto trace = trace_builder.finalize(); - -// auto selectRow = [](Row r) { return r.avmMini_sel_op_add == FF(1); }; -// mutateIcInTrace(trace, std::move(selectRow), FF(40)); - -// // TODO: check that the expected sub-relation failed -// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); -// } - -// // Test on basic incorrect subtraction over finite field type. -// TEST_F(AvmMiniArithmeticNegativeTests, subtractionFF) -// { -// trace_builder.callDataCopy(0, 3, 0, std::vector{ 8, 4, 17 }); - -// // Memory layout: [8,4,17,0,0,0,....] -// trace_builder.sub(2, 0, 1); // [8,9,17,0,0,0....] -// trace_builder.returnOP(0, 3); -// auto trace = trace_builder.finalize(); - -// auto selectRow = [](Row r) { return r.avmMini_sel_op_sub == FF(1); }; -// mutateIcInTrace(trace, std::move(selectRow), FF(-9)); - -// // TODO: check that the expected sub-relation failed -// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); -// } - -// // Test on basic incorrect multiplication over finite field type. -// TEST_F(AvmMiniArithmeticNegativeTests, multiplicationFF) -// { -// trace_builder.callDataCopy(0, 3, 0, std::vector{ 5, 0, 20 }); - -// // Memory layout: [5,0,20,0,0,0,....] -// trace_builder.mul(2, 0, 1); // [5,100,20,0,0,0....] -// trace_builder.returnOP(0, 3); -// auto trace = trace_builder.finalize(); - -// auto selectRow = [](Row r) { return r.avmMini_sel_op_mul == FF(1); }; -// mutateIcInTrace(trace, std::move(selectRow), FF(1000)); - -// // TODO: check that the expected sub-relation failed -// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); -// } - -// // Test on basic incorrect division over finite field type. -// TEST_F(AvmMiniArithmeticNegativeTests, divisionFF) -// { -// trace_builder.callDataCopy(0, 2, 0, std::vector{ 15, 315 }); - -// // Memory layout: [15,315,0,0,0,0,....] -// trace_builder.div(1, 0, 2); // [15,315,21,0,0,0....] -// trace_builder.returnOP(0, 3); -// auto trace = trace_builder.finalize(); - -// auto selectRow = [](Row r) { return r.avmMini_sel_op_div == FF(1); }; -// mutateIcInTrace(trace, std::move(selectRow), FF(0)); - -// // TODO: check that the expected sub-relation failed -// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); -// } - -// // Test where division is not by zero but an operation error is wrongly raised -// // in the trace. -// TEST_F(AvmMiniArithmeticNegativeTests, divisionNoZeroButErrorFF) -// { -// trace_builder.callDataCopy(0, 2, 0, std::vector{ 15, 315 }); - -// // Memory layout: [15,315,0,0,0,0,....] -// trace_builder.div(1, 0, 2); // [15,315,21,0,0,0....] -// trace_builder.returnOP(0, 3); -// auto trace = trace_builder.finalize(); - -// // Find the first row enabling the division selector -// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); - -// // Activate the operator error -// row->avmMini_op_err = FF(1); - -// // TODO: check that the expected sub-relation failed -// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); -// } +// Test on basic addition over finite field type. +TEST_F(AvmMiniControlFlowTests, simpleCallAndReturn) +{ + uint32_t const CALL_ADDRESS = 20; + uint32_t const RETURN_ADDRESS = 1; + // trace_builder for the following operation + // pc opcode + // 0 INTERNAL_CALL(pc=20) + // 20 INTERNAL_RETURN + // 1 HALT + trace_builder.internal_call(CALL_ADDRESS); + trace_builder.internal_return(); + trace_builder.halt(); -// // Test with division by zero occurs and no error is raised (remove error flag) -// TEST_F(AvmMiniArithmeticNegativeTests, divisionByZeroNoErrorFF) -// { -// trace_builder.callDataCopy(0, 1, 0, std::vector{ 15 }); + auto trace = trace_builder.finalize(); -// // Memory layout: [15,0,0,0,0,0,....] -// trace_builder.div(0, 1, 2); // [15,0,0,0,0,0....] -// auto trace = trace_builder.finalize(); + info("Built circuit with ", trace.size(), " rows"); -// // Find the first row enabling the division selector -// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_div == FF(1); }); + // Find the row of the call + auto call_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_call == FF(1); }); + EXPECT_TRUE(call_row != trace.end()); + EXPECT_EQ(call_row->avmMini_pc, FF(0)); + EXPECT_EQ(call_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); + EXPECT_EQ(call_row->avmMini_ia, FF(0)); + EXPECT_EQ(call_row->avmMini_mem_idx_a, + FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); // Store the return address (0) in memory -// // Remove the operator error flag -// row->avmMini_op_err = FF(0); + // Return row + auto return_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_return == FF(1); }); -// // TODO: check that the expected sub-relation failed -// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); -// } + // Check that the correct result is stored at the expected memory location. + EXPECT_TRUE(return_row != trace.end()); + EXPECT_EQ(return_row->avmMini_pc, FF(CALL_ADDRESS)); + EXPECT_EQ(return_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); -// // Test that error flag cannot be raised for a non-relevant operation such as -// // the addition, subtraction, multiplication. -// TEST_F(AvmMiniArithmeticNegativeTests, operationWithErrorFlagFF) -// { -// trace_builder.callDataCopy(0, 3, 0, std::vector{ 37, 4, 11 }); + // Halt row + auto halt_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_halt == FF(1); }); -// // Memory layout: [37,4,11,0,0,0,....] -// trace_builder.add(0, 1, 4); // [37,4,11,0,41,0,....] -// trace_builder.returnOP(0, 5); -// auto trace = trace_builder.finalize(); + EXPECT_TRUE(halt_row != trace.end()); + EXPECT_EQ(halt_row->avmMini_pc, FF(RETURN_ADDRESS)); -// // Find the first row enabling the addition selector -// auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_add == FF(1); }); + validateTraceProof(std::move(trace)); +} -// // Activate the operator error -// row->avmMini_op_err = FF(1); +TEST_F(AvmMiniControlFlowTests, multipleCallsAndReturns) +{ + uint32_t const CALL_ADDRESS_1 = 420; + uint32_t const CALL_ADDRESS_2 = 69; + uint32_t const CALL_ADDRESS_3 = 1337; + uint32_t const CALL_ADDRESS_4 = 4; -// // TODO: check that the expected sub-relation failed -// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); + // trace_builder for the following operation + // pc opcode + // 0 INTERNAL_CALL(pc=420) + // 420 INTERNAL_CALL(pc=69) + // 69 INTERNAL_CALL(pc=1337) + // 1337 INTERNAL_RETURN + // 70 INTERNAL_CALL(pc=4) + // 4 INTERNAL_RETURN + // 71 INTERNAL_RETURN + // 421 INTERNAL_RETURN + // 1 HALT + trace_builder.internal_call(CALL_ADDRESS_1); + trace_builder.internal_call(CALL_ADDRESS_2); + trace_builder.internal_call(CALL_ADDRESS_3); + trace_builder.internal_return(); + trace_builder.internal_call(CALL_ADDRESS_4); + trace_builder.internal_return(); + trace_builder.internal_return(); + trace_builder.internal_return(); + trace_builder.halt(); -// trace_builder.reset(); + auto trace = trace_builder.finalize(); -// trace_builder.callDataCopy(0, 3, 0, std::vector{ 8, 4, 17 }); + info("Built circuit with ", trace.size(), " rows"); -// // Memory layout: [8,4,17,0,0,0,....] -// trace_builder.sub(2, 0, 1); // [8,9,17,0,0,0....] -// trace_builder.returnOP(0, 3); -// trace = trace_builder.finalize(); + // Check call 1 + { + auto call_1 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { + return r.avmMini_sel_internal_call == FF(1) && r.avmMini_ia == FF(0); + }); + EXPECT_TRUE(call_1 != trace.end()); + EXPECT_EQ(call_1->avmMini_pc, FF(0)); + EXPECT_EQ(call_1->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); + EXPECT_EQ(call_1->avmMini_mem_idx_a, + FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); // Store the return address (0) in memory + } -// // Find the first row enabling the subtraction selector -// row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_sub == FF(1); }); + // Call 2 + { + auto call_2 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { + return r.avmMini_sel_internal_call == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_1); + }); + EXPECT_TRUE(call_2 != trace.end()); + EXPECT_EQ(call_2->avmMini_pc, FF(CALL_ADDRESS_1)); + EXPECT_EQ(call_2->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); + EXPECT_EQ(call_2->avmMini_mem_idx_a, + FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); // Store the return address (0) in memory + } -// // Activate the operator error -// row->avmMini_op_err = FF(1); + // Call 3 + { + auto call_3 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { + return r.avmMini_sel_internal_call == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_2); + }); + EXPECT_TRUE(call_3 != trace.end()); + EXPECT_EQ(call_3->avmMini_pc, FF(CALL_ADDRESS_2)); + EXPECT_EQ(call_3->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); + EXPECT_EQ(call_3->avmMini_mem_idx_a, + FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); // Store the return address (0) in memory + } -// // TODO: check that the expected sub-relation failed -// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); + // Return 1 + { + auto return_1 = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_return == FF(1); }); + EXPECT_TRUE(return_1 != trace.end()); + EXPECT_EQ(return_1->avmMini_pc, FF(CALL_ADDRESS_3)); + EXPECT_EQ(return_1->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 3)); + } -// trace_builder.reset(); + // Call 4 + { + auto call_4 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { + return r.avmMini_sel_internal_call == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_2 + 1); + }); + EXPECT_TRUE(call_4 != trace.end()); + EXPECT_EQ(call_4->avmMini_pc, FF(CALL_ADDRESS_2 + 1)); + EXPECT_EQ(call_4->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); + EXPECT_EQ(call_4->avmMini_mem_idx_a, + FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); // Store the return address (0) in memory + } -// trace_builder.callDataCopy(0, 3, 0, std::vector{ 5, 0, 20 }); + // Return 2 + { + auto return_2 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { + return r.avmMini_sel_internal_return == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_2 + 1); + }); + EXPECT_TRUE(return_2 != trace.end()); + EXPECT_EQ(return_2->avmMini_pc, FF(CALL_ADDRESS_4)); + EXPECT_EQ(return_2->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 3)); + } -// // Memory layout: [5,0,20,0,0,0,....] -// trace_builder.mul(2, 0, 1); // [5,100,20,0,0,0....] -// trace_builder.returnOP(0, 3); -// trace = trace_builder.finalize(); + // Return 3 + { + auto return_3 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { + return r.avmMini_sel_internal_return == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_1); + }); + EXPECT_TRUE(return_3 != trace.end()); + EXPECT_EQ(return_3->avmMini_pc, FF(CALL_ADDRESS_2 + 2)); + EXPECT_EQ(return_3->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); + } -// // Find the first row enabling the multiplication selector -// row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_mul == FF(1); }); + // Return 4 + { + auto return_4 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { + return r.avmMini_sel_internal_return == FF(1) && r.avmMini_ia == FF(0); + }); + EXPECT_TRUE(return_4 != trace.end()); + EXPECT_EQ(return_4->avmMini_pc, FF(CALL_ADDRESS_1 + 1)); + EXPECT_EQ(return_4->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); + } -// // Activate the operator error -// row->avmMini_op_err = FF(1); + // Halt row + auto halt_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_halt == FF(1); }); -// // TODO: check that the expected sub-relation failed -// EXPECT_ANY_THROW(validateTraceProof(std::move(trace))); -// } + EXPECT_TRUE(halt_row != trace.end()); + EXPECT_EQ(halt_row->avmMini_pc, FF(1)); + validateTraceProof(std::move(trace)); +} } // namespace tests_avm \ No newline at end of file From cfe5b71fd83ca52c50b3ee8cbd4af4144e00c12f Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 18 Dec 2023 22:30:21 +0000 Subject: [PATCH 06/10] fix: store the incremented return destination in the call stack --- barretenberg/cpp/pil/avm/avm_mini.pil | 4 +- .../flavor/generated/AvmMini_flavor.hpp | 12 ++--- .../circuit_builder/AvmMini_trace.cpp | 23 +++------- .../generated/AvmMini_circuit_builder.hpp | 4 +- .../relations/generated/AvmMini/avm_mini.hpp | 44 +++++++++---------- .../generated/AvmMini/declare_views.hpp | 2 +- .../relations/generated/AvmMini/mem_trace.hpp | 10 ++--- .../vm/tests/AvmMini_control_flow.test.cpp | 36 +++++++-------- 8 files changed, 60 insertions(+), 75 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index 94a05cd52bf5..84e34a2937ef 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -132,13 +132,13 @@ namespace avmMini(256); sel_internal_call * ( internal_return_ptr - mem_idx_a) = 0; sel_internal_call * (rwa - 1) = 0; // it must be a write sel_internal_call * (mem_op_a - 1) = 0; - sel_internal_call * (pc - ia) = 0; + sel_internal_call * ((pc + 1) - ia) = 0; // We must load the memory pointer to be the internal_return_ptr #[return_pointer_decrement] sel_internal_return * ( internal_return_ptr' - ( internal_return_ptr - 1)) = 0; // We decrement out jump selector sel_internal_return * ( (internal_return_ptr - 1) - mem_idx_a) = 0; - sel_internal_return * (pc' - (ia+1)) = 0; + sel_internal_return * (pc' - ia) = 0; sel_internal_return * rwa = 0; sel_internal_return * (mem_op_a - 1) = 0; diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp index 26d8869e8a2b..79a79cb71572 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp @@ -178,9 +178,9 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, + memTrace_m_val_shift, memTrace_m_addr_shift, memTrace_m_rw_shift, - memTrace_m_val_shift, avmMini_pc_shift, avmMini_internal_return_ptr_shift) @@ -218,9 +218,9 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, + memTrace_m_val_shift, memTrace_m_addr_shift, memTrace_m_rw_shift, - memTrace_m_val_shift, avmMini_pc_shift, avmMini_internal_return_ptr_shift }; }; @@ -261,13 +261,13 @@ class AvmMiniFlavor { }; RefVector get_to_be_shifted() { - return { memTrace_m_addr, memTrace_m_rw, memTrace_m_val, avmMini_pc, avmMini_internal_return_ptr }; + return { memTrace_m_val, memTrace_m_addr, memTrace_m_rw, avmMini_pc, avmMini_internal_return_ptr }; }; RefVector get_shifted() { - return { memTrace_m_addr_shift, + return { memTrace_m_val_shift, + memTrace_m_addr_shift, memTrace_m_rw_shift, - memTrace_m_val_shift, avmMini_pc_shift, avmMini_internal_return_ptr_shift }; }; @@ -282,7 +282,7 @@ class AvmMiniFlavor { RefVector get_to_be_shifted() { - return { memTrace_m_addr, memTrace_m_rw, memTrace_m_val, avmMini_pc, avmMini_internal_return_ptr }; + return { memTrace_m_val, memTrace_m_addr, memTrace_m_rw, avmMini_pc, avmMini_internal_return_ptr }; }; // The plookup wires that store plookup read data. diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index 0fcb21d62e2f..2c09cbcc1115 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -540,9 +540,6 @@ void AvmMiniTraceBuilder::halt() { auto clk = mainTrace.size(); - info("pc at halt: ", pc); - info("return pointer at halt: ", internal_return_ptr); - mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc), @@ -555,28 +552,27 @@ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) { auto clk = mainTrace.size(); - // TODO: make sure this is initialized - internal_call_stack.push(pc); + uint32_t stored_pc = pc + 1; + internal_call_stack.push(stored_pc); // We want to write the current pc to the memory location pointed by - storeAInMemTrace(internal_return_ptr, FF(pc)); + storeAInMemTrace(internal_return_ptr, FF(stored_pc)); - // TODO: we need a better way to insert globals into the trace mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc), .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_internal_call = FF(1), - .avmMini_ia = pc, + .avmMini_ia = stored_pc, .avmMini_mem_op_a = FF(1), .avmMini_rwa = FF(1), .avmMini_mem_idx_a = FF(internal_return_ptr), }); // We want the next row to be the one pointed by jmpDest - ffMemory.at(internal_return_ptr) = pc; + ffMemory.at(internal_return_ptr) = stored_pc; pc = jmpDest; - this->internal_return_ptr++; + internal_return_ptr++; } void AvmMiniTraceBuilder::internal_return() @@ -586,9 +582,6 @@ void AvmMiniTraceBuilder::internal_return() // Internal return pointer is decremented FF a = ffMemory.at(internal_return_ptr - 1); - info("The internal pointer ", internal_return_ptr); - info("The internal pointer value", a); - // We want to load the value pointed by the internal pointer loadAInMemTrace(internal_return_ptr - 1, FF(a)); @@ -604,10 +597,8 @@ void AvmMiniTraceBuilder::internal_return() }); // We want the next row to be the one pointed by jmpDest - // TODO: is this type casting safe - // The next pc should be from the top of the internal call stack + 1 - pc = internal_call_stack.top() + 1; + pc = internal_call_stack.top(); internal_call_stack.pop(); internal_return_ptr--; } diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp index d86b27eba0ba..977d35d11333 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp @@ -51,9 +51,9 @@ template struct AvmMiniFullRow { FF avmMini_mem_idx_b{}; FF avmMini_mem_idx_c{}; FF avmMini_last{}; + FF memTrace_m_val_shift{}; FF memTrace_m_addr_shift{}; FF memTrace_m_rw_shift{}; - FF memTrace_m_val_shift{}; FF avmMini_pc_shift{}; FF avmMini_internal_return_ptr_shift{}; }; @@ -119,9 +119,9 @@ class AvmMiniCircuitBuilder { polys.avmMini_last[i] = rows[i].avmMini_last; } + polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); - polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp index 84fbc07be8c0..0f0d85b093e4 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp @@ -7,43 +7,43 @@ namespace proof_system::AvmMini_vm { template struct Avm_miniRow { - FF avmMini_pc_shift{}; - FF avmMini_mem_op_b{}; - FF avmMini_mem_op_c{}; - FF avmMini_ib{}; FF avmMini_mem_op_a{}; - FF avmMini_sel_internal_call{}; - FF avmMini_op_err{}; - FF avmMini_sel_op_div{}; - FF avmMini_sel_op_sub{}; - FF avmMini_sel_internal_return{}; - FF avmMini_rwb{}; + FF avmMini_sel_op_add{}; FF avmMini_sel_op_mul{}; - FF avmMini_ia{}; + FF avmMini_mem_op_c{}; + FF avmMini_sel_internal_call{}; FF avmMini_mem_idx_a{}; - FF avmMini_sel_halt{}; - FF avmMini_inv{}; - FF avmMini_ic{}; - FF avmMini_sel_op_add{}; FF avmMini_rwa{}; - FF avmMini_rwc{}; - FF avmMini_internal_return_ptr_shift{}; + FF avmMini_sel_op_sub{}; FF avmMini_first{}; FF avmMini_pc{}; + FF avmMini_ib{}; + FF avmMini_sel_halt{}; + FF avmMini_op_err{}; + FF avmMini_pc_shift{}; + FF avmMini_rwc{}; + FF avmMini_ic{}; + FF avmMini_inv{}; + FF avmMini_mem_op_b{}; + FF avmMini_internal_return_ptr_shift{}; + FF avmMini_rwb{}; + FF avmMini_sel_internal_return{}; + FF avmMini_sel_op_div{}; + FF avmMini_ia{}; FF avmMini_internal_return_ptr{}; }; inline std::string get_relation_label_avm_mini(int index) { switch (index) { - case 28: - return "pc_increment"; - case 23: return "return_pointer_decrement"; case 18: return "return_pointer_increment"; + + case 28: + return "pc_increment"; } return std::to_string(index); } @@ -244,7 +244,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(22); - auto tmp = (avmMini_sel_internal_call * (avmMini_pc - avmMini_ia)); + auto tmp = (avmMini_sel_internal_call * ((avmMini_pc + FF(1)) - avmMini_ia)); tmp *= scaling_factor; std::get<22>(evals) += tmp; } @@ -269,7 +269,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(25); - auto tmp = (avmMini_sel_internal_return * (avmMini_pc_shift - (avmMini_ia + FF(1)))); + auto tmp = (avmMini_sel_internal_return * (avmMini_pc_shift - avmMini_ia)); tmp *= scaling_factor; std::get<25>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp index f53f99371e16..2c8c81c210be 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp @@ -34,8 +34,8 @@ [[maybe_unused]] auto avmMini_mem_idx_b = View(new_term.avmMini_mem_idx_b); \ [[maybe_unused]] auto avmMini_mem_idx_c = View(new_term.avmMini_mem_idx_c); \ [[maybe_unused]] auto avmMini_last = View(new_term.avmMini_last); \ + [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ - [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp index b9e99924418c..a161c9979ffe 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp @@ -7,15 +7,15 @@ namespace proof_system::AvmMini_vm { template struct Mem_traceRow { - FF memTrace_m_addr_shift{}; - FF memTrace_m_rw{}; + FF memTrace_m_lastAccess{}; FF avmMini_last{}; FF memTrace_m_val{}; - FF memTrace_m_lastAccess{}; - FF avmMini_first{}; FF memTrace_m_addr{}; - FF memTrace_m_rw_shift{}; + FF avmMini_first{}; + FF memTrace_m_rw{}; FF memTrace_m_val_shift{}; + FF memTrace_m_addr_shift{}; + FF memTrace_m_rw_shift{}; }; inline std::string get_relation_label_mem_trace(int index) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp index 5ea342911d81..2c224e75c848 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp @@ -79,15 +79,13 @@ TEST_F(AvmMiniControlFlowTests, simpleCall) auto trace = trace_builder.finalize(); - info("Built circuit with ", trace.size(), " rows"); - // Find the row of the call auto call_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_call == FF(1); }); EXPECT_TRUE(call_row != trace.end()); EXPECT_EQ(call_row->avmMini_pc, FF(0)); EXPECT_EQ(call_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); - EXPECT_EQ(call_row->avmMini_ia, FF(0)); + EXPECT_EQ(call_row->avmMini_ia, FF(1)); EXPECT_EQ(call_row->avmMini_mem_idx_a, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); // Store the return address (0) in memory @@ -118,15 +116,13 @@ TEST_F(AvmMiniControlFlowTests, simpleCallAndReturn) auto trace = trace_builder.finalize(); - info("Built circuit with ", trace.size(), " rows"); - // Find the row of the call auto call_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_call == FF(1); }); EXPECT_TRUE(call_row != trace.end()); EXPECT_EQ(call_row->avmMini_pc, FF(0)); EXPECT_EQ(call_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); - EXPECT_EQ(call_row->avmMini_ia, FF(0)); + EXPECT_EQ(call_row->avmMini_ia, FF(1)); EXPECT_EQ(call_row->avmMini_mem_idx_a, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); // Store the return address (0) in memory @@ -178,12 +174,10 @@ TEST_F(AvmMiniControlFlowTests, multipleCallsAndReturns) auto trace = trace_builder.finalize(); - info("Built circuit with ", trace.size(), " rows"); - // Check call 1 { auto call_1 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.avmMini_sel_internal_call == FF(1) && r.avmMini_ia == FF(0); + return r.avmMini_sel_internal_call == FF(1) && r.avmMini_ia == FF(1); }); EXPECT_TRUE(call_1 != trace.end()); EXPECT_EQ(call_1->avmMini_pc, FF(0)); @@ -195,10 +189,10 @@ TEST_F(AvmMiniControlFlowTests, multipleCallsAndReturns) // Call 2 { auto call_2 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.avmMini_sel_internal_call == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_1); + return r.avmMini_sel_internal_call == FF(1) && r.avmMini_pc == FF(CALL_ADDRESS_1); }); EXPECT_TRUE(call_2 != trace.end()); - EXPECT_EQ(call_2->avmMini_pc, FF(CALL_ADDRESS_1)); + EXPECT_EQ(call_2->avmMini_ia, FF(CALL_ADDRESS_1 + 1)); EXPECT_EQ(call_2->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); EXPECT_EQ(call_2->avmMini_mem_idx_a, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); // Store the return address (0) in memory @@ -207,10 +201,10 @@ TEST_F(AvmMiniControlFlowTests, multipleCallsAndReturns) // Call 3 { auto call_3 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.avmMini_sel_internal_call == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_2); + return r.avmMini_sel_internal_call == FF(1) && r.avmMini_pc == FF(CALL_ADDRESS_2); }); EXPECT_TRUE(call_3 != trace.end()); - EXPECT_EQ(call_3->avmMini_pc, FF(CALL_ADDRESS_2)); + EXPECT_EQ(call_3->avmMini_ia, FF(CALL_ADDRESS_2 + 1)); EXPECT_EQ(call_3->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); EXPECT_EQ(call_3->avmMini_mem_idx_a, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); // Store the return address (0) in memory @@ -228,10 +222,10 @@ TEST_F(AvmMiniControlFlowTests, multipleCallsAndReturns) // Call 4 { auto call_4 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.avmMini_sel_internal_call == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_2 + 1); + return r.avmMini_sel_internal_call == FF(1) && r.avmMini_pc == FF(CALL_ADDRESS_2 + 1); }); EXPECT_TRUE(call_4 != trace.end()); - EXPECT_EQ(call_4->avmMini_pc, FF(CALL_ADDRESS_2 + 1)); + EXPECT_EQ(call_4->avmMini_ia, FF(CALL_ADDRESS_2 + 2)); EXPECT_EQ(call_4->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); EXPECT_EQ(call_4->avmMini_mem_idx_a, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); // Store the return address (0) in memory @@ -240,30 +234,30 @@ TEST_F(AvmMiniControlFlowTests, multipleCallsAndReturns) // Return 2 { auto return_2 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.avmMini_sel_internal_return == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_2 + 1); + return r.avmMini_sel_internal_return == FF(1) && r.avmMini_pc == FF(CALL_ADDRESS_4); }); EXPECT_TRUE(return_2 != trace.end()); - EXPECT_EQ(return_2->avmMini_pc, FF(CALL_ADDRESS_4)); + EXPECT_EQ(return_2->avmMini_ia, FF(CALL_ADDRESS_2 + 2)); EXPECT_EQ(return_2->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 3)); } // Return 3 { auto return_3 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.avmMini_sel_internal_return == FF(1) && r.avmMini_ia == FF(CALL_ADDRESS_1); + return r.avmMini_sel_internal_return == FF(1) && r.avmMini_pc == FF(CALL_ADDRESS_2 + 2); }); EXPECT_TRUE(return_3 != trace.end()); - EXPECT_EQ(return_3->avmMini_pc, FF(CALL_ADDRESS_2 + 2)); + EXPECT_EQ(return_3->avmMini_ia, FF(CALL_ADDRESS_1 + 1)); EXPECT_EQ(return_3->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 2)); } // Return 4 { auto return_4 = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { - return r.avmMini_sel_internal_return == FF(1) && r.avmMini_ia == FF(0); + return r.avmMini_sel_internal_return == FF(1) && r.avmMini_pc == FF(CALL_ADDRESS_1 + 1); }); EXPECT_TRUE(return_4 != trace.end()); - EXPECT_EQ(return_4->avmMini_pc, FF(CALL_ADDRESS_1 + 1)); + EXPECT_EQ(return_4->avmMini_ia, FF(1)); EXPECT_EQ(return_4->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); } From 97480e155531ba4bc4749e2b320e9acd77cff5c6 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 18 Dec 2023 22:46:13 +0000 Subject: [PATCH 07/10] fix: constrain selectors are boolean --- barretenberg/cpp/pil/avm/avm_mini.pil | 5 + .../flavor/generated/AvmMini_flavor.hpp | 10 +- .../generated/AvmMini_circuit_builder.hpp | 4 +- .../relations/generated/AvmMini/avm_mini.hpp | 124 +++++++++++------- .../generated/AvmMini/declare_views.hpp | 2 +- .../relations/generated/AvmMini/mem_trace.hpp | 8 +- 6 files changed, 95 insertions(+), 58 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index 84e34a2937ef..0c0c0895a9e2 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -73,6 +73,11 @@ namespace avmMini(256); sel_op_sub * (1 - sel_op_sub) = 0; sel_op_mul * (1 - sel_op_mul) = 0; sel_op_div * (1 - sel_op_div) = 0; + sel_op_div * (1 - sel_op_div) = 0; + + sel_internal_call * (1 - sel_internal_call) = 0; + sel_internal_return * (1 - sel_internal_return) = 0; + sel_halt * (1 - sel_halt) = 0; op_err * (1 - op_err) = 0; diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp index 79a79cb71572..6af5682b343b 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp @@ -179,8 +179,8 @@ class AvmMiniFlavor { avmMini_mem_idx_c, avmMini_last, memTrace_m_val_shift, - memTrace_m_addr_shift, memTrace_m_rw_shift, + memTrace_m_addr_shift, avmMini_pc_shift, avmMini_internal_return_ptr_shift) @@ -219,8 +219,8 @@ class AvmMiniFlavor { avmMini_mem_idx_c, avmMini_last, memTrace_m_val_shift, - memTrace_m_addr_shift, memTrace_m_rw_shift, + memTrace_m_addr_shift, avmMini_pc_shift, avmMini_internal_return_ptr_shift }; }; @@ -261,13 +261,13 @@ class AvmMiniFlavor { }; RefVector get_to_be_shifted() { - return { memTrace_m_val, memTrace_m_addr, memTrace_m_rw, avmMini_pc, avmMini_internal_return_ptr }; + return { memTrace_m_val, memTrace_m_rw, memTrace_m_addr, avmMini_pc, avmMini_internal_return_ptr }; }; RefVector get_shifted() { return { memTrace_m_val_shift, - memTrace_m_addr_shift, memTrace_m_rw_shift, + memTrace_m_addr_shift, avmMini_pc_shift, avmMini_internal_return_ptr_shift }; }; @@ -282,7 +282,7 @@ class AvmMiniFlavor { RefVector get_to_be_shifted() { - return { memTrace_m_val, memTrace_m_addr, memTrace_m_rw, avmMini_pc, avmMini_internal_return_ptr }; + return { memTrace_m_val, memTrace_m_rw, memTrace_m_addr, avmMini_pc, avmMini_internal_return_ptr }; }; // The plookup wires that store plookup read data. diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp index 977d35d11333..8904c0145dc5 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp @@ -52,8 +52,8 @@ template struct AvmMiniFullRow { FF avmMini_mem_idx_c{}; FF avmMini_last{}; FF memTrace_m_val_shift{}; - FF memTrace_m_addr_shift{}; FF memTrace_m_rw_shift{}; + FF memTrace_m_addr_shift{}; FF avmMini_pc_shift{}; FF avmMini_internal_return_ptr_shift{}; }; @@ -120,8 +120,8 @@ class AvmMiniCircuitBuilder { } polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); - polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); + polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp index 0f0d85b093e4..99ca3ad99881 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp @@ -7,42 +7,42 @@ namespace proof_system::AvmMini_vm { template struct Avm_miniRow { - FF avmMini_mem_op_a{}; - FF avmMini_sel_op_add{}; - FF avmMini_sel_op_mul{}; - FF avmMini_mem_op_c{}; + FF avmMini_rwb{}; FF avmMini_sel_internal_call{}; FF avmMini_mem_idx_a{}; - FF avmMini_rwa{}; - FF avmMini_sel_op_sub{}; FF avmMini_first{}; - FF avmMini_pc{}; - FF avmMini_ib{}; + FF avmMini_sel_op_mul{}; + FF avmMini_sel_op_sub{}; FF avmMini_sel_halt{}; + FF avmMini_sel_op_add{}; + FF avmMini_rwa{}; + FF avmMini_mem_op_c{}; + FF avmMini_pc{}; FF avmMini_op_err{}; - FF avmMini_pc_shift{}; + FF avmMini_mem_op_a{}; + FF avmMini_mem_op_b{}; + FF avmMini_sel_op_div{}; FF avmMini_rwc{}; - FF avmMini_ic{}; + FF avmMini_ib{}; FF avmMini_inv{}; - FF avmMini_mem_op_b{}; + FF avmMini_ia{}; + FF avmMini_pc_shift{}; FF avmMini_internal_return_ptr_shift{}; - FF avmMini_rwb{}; + FF avmMini_ic{}; FF avmMini_sel_internal_return{}; - FF avmMini_sel_op_div{}; - FF avmMini_ia{}; FF avmMini_internal_return_ptr{}; }; inline std::string get_relation_label_avm_mini(int index) { switch (index) { - case 23: + case 27: return "return_pointer_decrement"; - case 18: + case 22: return "return_pointer_increment"; - case 28: + case 32: return "pc_increment"; } return std::to_string(index); @@ -52,8 +52,8 @@ template class avm_miniImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, }; template @@ -99,7 +99,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(4); - auto tmp = (avmMini_op_err * (-avmMini_op_err + FF(1))); + auto tmp = (avmMini_sel_op_div * (-avmMini_sel_op_div + FF(1))); tmp *= scaling_factor; std::get<4>(evals) += tmp; } @@ -107,7 +107,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(5); - auto tmp = (avmMini_mem_op_a * (-avmMini_mem_op_a + FF(1))); + auto tmp = (avmMini_sel_internal_call * (-avmMini_sel_internal_call + FF(1))); tmp *= scaling_factor; std::get<5>(evals) += tmp; } @@ -115,7 +115,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(6); - auto tmp = (avmMini_mem_op_b * (-avmMini_mem_op_b + FF(1))); + auto tmp = (avmMini_sel_internal_return * (-avmMini_sel_internal_return + FF(1))); tmp *= scaling_factor; std::get<6>(evals) += tmp; } @@ -123,7 +123,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(7); - auto tmp = (avmMini_mem_op_c * (-avmMini_mem_op_c + FF(1))); + auto tmp = (avmMini_sel_halt * (-avmMini_sel_halt + FF(1))); tmp *= scaling_factor; std::get<7>(evals) += tmp; } @@ -131,7 +131,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(8); - auto tmp = (avmMini_rwa * (-avmMini_rwa + FF(1))); + auto tmp = (avmMini_op_err * (-avmMini_op_err + FF(1))); tmp *= scaling_factor; std::get<8>(evals) += tmp; } @@ -139,7 +139,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(9); - auto tmp = (avmMini_rwb * (-avmMini_rwb + FF(1))); + auto tmp = (avmMini_mem_op_a * (-avmMini_mem_op_a + FF(1))); tmp *= scaling_factor; std::get<9>(evals) += tmp; } @@ -147,7 +147,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(10); - auto tmp = (avmMini_rwc * (-avmMini_rwc + FF(1))); + auto tmp = (avmMini_mem_op_b * (-avmMini_mem_op_b + FF(1))); tmp *= scaling_factor; std::get<10>(evals) += tmp; } @@ -155,7 +155,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(11); - auto tmp = (avmMini_sel_op_add * ((avmMini_ia + avmMini_ib) - avmMini_ic)); + auto tmp = (avmMini_mem_op_c * (-avmMini_mem_op_c + FF(1))); tmp *= scaling_factor; std::get<11>(evals) += tmp; } @@ -163,7 +163,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(12); - auto tmp = (avmMini_sel_op_sub * ((avmMini_ia - avmMini_ib) - avmMini_ic)); + auto tmp = (avmMini_rwa * (-avmMini_rwa + FF(1))); tmp *= scaling_factor; std::get<12>(evals) += tmp; } @@ -171,7 +171,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(13); - auto tmp = (avmMini_sel_op_mul * ((avmMini_ia * avmMini_ib) - avmMini_ic)); + auto tmp = (avmMini_rwb * (-avmMini_rwb + FF(1))); tmp *= scaling_factor; std::get<13>(evals) += tmp; } @@ -179,7 +179,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(14); - auto tmp = ((avmMini_sel_op_div * (-avmMini_op_err + FF(1))) * ((avmMini_ic * avmMini_ib) - avmMini_ia)); + auto tmp = (avmMini_rwc * (-avmMini_rwc + FF(1))); tmp *= scaling_factor; std::get<14>(evals) += tmp; } @@ -187,7 +187,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(15); - auto tmp = (avmMini_sel_op_div * (((avmMini_ib * avmMini_inv) - FF(1)) + avmMini_op_err)); + auto tmp = (avmMini_sel_op_add * ((avmMini_ia + avmMini_ib) - avmMini_ic)); tmp *= scaling_factor; std::get<15>(evals) += tmp; } @@ -195,7 +195,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(16); - auto tmp = ((avmMini_sel_op_div * avmMini_op_err) * (-avmMini_inv + FF(1))); + auto tmp = (avmMini_sel_op_sub * ((avmMini_ia - avmMini_ib) - avmMini_ic)); tmp *= scaling_factor; std::get<16>(evals) += tmp; } @@ -203,7 +203,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(17); - auto tmp = (avmMini_op_err * (avmMini_sel_op_div - FF(1))); + auto tmp = (avmMini_sel_op_mul * ((avmMini_ia * avmMini_ib) - avmMini_ic)); tmp *= scaling_factor; std::get<17>(evals) += tmp; } @@ -211,8 +211,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(18); - auto tmp = (avmMini_sel_internal_call * - (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr + FF(1)))); + auto tmp = ((avmMini_sel_op_div * (-avmMini_op_err + FF(1))) * ((avmMini_ic * avmMini_ib) - avmMini_ia)); tmp *= scaling_factor; std::get<18>(evals) += tmp; } @@ -220,7 +219,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(19); - auto tmp = (avmMini_sel_internal_call * (avmMini_internal_return_ptr - avmMini_mem_idx_a)); + auto tmp = (avmMini_sel_op_div * (((avmMini_ib * avmMini_inv) - FF(1)) + avmMini_op_err)); tmp *= scaling_factor; std::get<19>(evals) += tmp; } @@ -228,7 +227,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(20); - auto tmp = (avmMini_sel_internal_call * (avmMini_rwa - FF(1))); + auto tmp = ((avmMini_sel_op_div * avmMini_op_err) * (-avmMini_inv + FF(1))); tmp *= scaling_factor; std::get<20>(evals) += tmp; } @@ -236,7 +235,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(21); - auto tmp = (avmMini_sel_internal_call * (avmMini_mem_op_a - FF(1))); + auto tmp = (avmMini_op_err * (avmMini_sel_op_div - FF(1))); tmp *= scaling_factor; std::get<21>(evals) += tmp; } @@ -244,7 +243,8 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(22); - auto tmp = (avmMini_sel_internal_call * ((avmMini_pc + FF(1)) - avmMini_ia)); + auto tmp = (avmMini_sel_internal_call * + (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr + FF(1)))); tmp *= scaling_factor; std::get<22>(evals) += tmp; } @@ -252,8 +252,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(23); - auto tmp = (avmMini_sel_internal_return * - (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr - FF(1)))); + auto tmp = (avmMini_sel_internal_call * (avmMini_internal_return_ptr - avmMini_mem_idx_a)); tmp *= scaling_factor; std::get<23>(evals) += tmp; } @@ -261,7 +260,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(24); - auto tmp = (avmMini_sel_internal_return * ((avmMini_internal_return_ptr - FF(1)) - avmMini_mem_idx_a)); + auto tmp = (avmMini_sel_internal_call * (avmMini_rwa - FF(1))); tmp *= scaling_factor; std::get<24>(evals) += tmp; } @@ -269,7 +268,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(25); - auto tmp = (avmMini_sel_internal_return * (avmMini_pc_shift - avmMini_ia)); + auto tmp = (avmMini_sel_internal_call * (avmMini_mem_op_a - FF(1))); tmp *= scaling_factor; std::get<25>(evals) += tmp; } @@ -277,7 +276,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(26); - auto tmp = (avmMini_sel_internal_return * avmMini_rwa); + auto tmp = (avmMini_sel_internal_call * ((avmMini_pc + FF(1)) - avmMini_ia)); tmp *= scaling_factor; std::get<26>(evals) += tmp; } @@ -285,7 +284,8 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(27); - auto tmp = (avmMini_sel_internal_return * (avmMini_mem_op_a - FF(1))); + auto tmp = (avmMini_sel_internal_return * + (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr - FF(1)))); tmp *= scaling_factor; std::get<27>(evals) += tmp; } @@ -293,11 +293,43 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(28); + auto tmp = (avmMini_sel_internal_return * ((avmMini_internal_return_ptr - FF(1)) - avmMini_mem_idx_a)); + tmp *= scaling_factor; + std::get<28>(evals) += tmp; + } + // Contribution 29 + { + AvmMini_DECLARE_VIEWS(29); + + auto tmp = (avmMini_sel_internal_return * (avmMini_pc_shift - avmMini_ia)); + tmp *= scaling_factor; + std::get<29>(evals) += tmp; + } + // Contribution 30 + { + AvmMini_DECLARE_VIEWS(30); + + auto tmp = (avmMini_sel_internal_return * avmMini_rwa); + tmp *= scaling_factor; + std::get<30>(evals) += tmp; + } + // Contribution 31 + { + AvmMini_DECLARE_VIEWS(31); + + auto tmp = (avmMini_sel_internal_return * (avmMini_mem_op_a - FF(1))); + tmp *= scaling_factor; + std::get<31>(evals) += tmp; + } + // Contribution 32 + { + AvmMini_DECLARE_VIEWS(32); + auto tmp = ((((-avmMini_first + FF(1)) * (-avmMini_sel_halt + FF(1))) * (((avmMini_sel_op_add + avmMini_sel_op_sub) + avmMini_sel_op_div) + avmMini_sel_op_mul)) * (avmMini_pc_shift - (avmMini_pc + FF(1)))); tmp *= scaling_factor; - std::get<28>(evals) += tmp; + std::get<32>(evals) += tmp; } } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp index 2c8c81c210be..d6313bed5a4e 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp @@ -35,7 +35,7 @@ [[maybe_unused]] auto avmMini_mem_idx_c = View(new_term.avmMini_mem_idx_c); \ [[maybe_unused]] auto avmMini_last = View(new_term.avmMini_last); \ [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ - [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ + [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp index a161c9979ffe..583f698937bc 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp @@ -9,13 +9,13 @@ namespace proof_system::AvmMini_vm { template struct Mem_traceRow { FF memTrace_m_lastAccess{}; FF avmMini_last{}; - FF memTrace_m_val{}; - FF memTrace_m_addr{}; + FF memTrace_m_val_shift{}; FF avmMini_first{}; + FF memTrace_m_rw_shift{}; + FF memTrace_m_val{}; FF memTrace_m_rw{}; - FF memTrace_m_val_shift{}; + FF memTrace_m_addr{}; FF memTrace_m_addr_shift{}; - FF memTrace_m_rw_shift{}; }; inline std::string get_relation_label_mem_trace(int index) From 75c772d4beaa3ae959faaaecb2e2ff6a869973ac Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Tue, 19 Dec 2023 15:20:46 +0000 Subject: [PATCH 08/10] fix: pr review comments --- barretenberg/cpp/pil/avm/avm_mini.pil | 25 ++-- .../flavor/generated/AvmMini_flavor.hpp | 24 ++-- .../circuit_builder/AvmMini_trace.cpp | 37 +++++- .../generated/AvmMini_circuit_builder.hpp | 20 +-- .../relations/generated/AvmMini/avm_mini.hpp | 114 +++++++++--------- .../generated/AvmMini/declare_views.hpp | 6 +- .../relations/generated/AvmMini/mem_trace.hpp | 10 +- .../vm/tests/AvmMini_control_flow.test.cpp | 92 +++++++------- 8 files changed, 190 insertions(+), 138 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index 0c0c0895a9e2..e1617d24dc21 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -73,7 +73,6 @@ namespace avmMini(256); sel_op_sub * (1 - sel_op_sub) = 0; sel_op_mul * (1 - sel_op_mul) = 0; sel_op_div * (1 - sel_op_div) = 0; - sel_op_div * (1 - sel_op_div) = 0; sel_internal_call * (1 - sel_internal_call) = 0; sel_internal_return * (1 - sel_internal_return) = 0; @@ -131,26 +130,36 @@ namespace avmMini(256); //===== CALL_RETURN ======================================================== // The program counter in the next row should be equal to the value loaded from the ia register // This implies that a load from memory must occur at the same time - // Imply that we must load the jump selector into mema - #[return_pointer_increment] + // Imply that we must load the return location into mem_idx_a + + #[RETURN_POINTER_INCREMENT] sel_internal_call * ( internal_return_ptr' - ( internal_return_ptr + 1)) = 0; // we increment our jump selector sel_internal_call * ( internal_return_ptr - mem_idx_a) = 0; - sel_internal_call * (rwa - 1) = 0; // it must be a write - sel_internal_call * (mem_op_a - 1) = 0; sel_internal_call * ((pc + 1) - ia) = 0; + // TODO(md): Below relations may be removed through sub-op table lookup + sel_internal_call * (rwa - 1) = 0; + sel_internal_call * (mem_op_a - 1) = 0; // We must load the memory pointer to be the internal_return_ptr - #[return_pointer_decrement] + #[RETURN_POINTER_DECREMENT] sel_internal_return * ( internal_return_ptr' - ( internal_return_ptr - 1)) = 0; // We decrement out jump selector sel_internal_return * ( (internal_return_ptr - 1) - mem_idx_a) = 0; sel_internal_return * (pc' - ia) = 0; + + // TODO(md): Below relations may be removed through sub-op table lookup sel_internal_return * rwa = 0; sel_internal_return * (mem_op_a - 1) = 0; + //===== CONTROL_FLOW_CONSITENCY ============================================ + pol CONTROL_FLOW_SELECTORS = (first + sel_internal_call + sel_internal_return + sel_halt); + pol OPCODE_SELECTORS = (sel_op_add + sel_op_sub + sel_op_div + sel_op_mul); + // Program counter must increment if not jumping or returning - #[pc_increment] - (1-first) * (1- sel_halt) * (sel_op_add + sel_op_sub + sel_op_div + sel_op_mul) * (pc' - (pc + 1)) = 0; + #[PC_INCREMENT] + (1 - first) * (1 - sel_halt) * OPCODE_SELECTORS * (pc' - (pc + 1)) = 0; + #[INTERNAL_RETURN_POINTER_CONSISTENCY] + (1 - CONTROL_FLOW_SELECTORS) * (internal_return_ptr' - internal_return_ptr) = 0; // TODO: we want to set an initial number for the reserved memory of the jump pointer diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp index 6af5682b343b..ce81d2d08663 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp @@ -42,7 +42,7 @@ class AvmMiniFlavor { // the unshifted and one for the shifted static constexpr size_t NUM_ALL_ENTITIES = 37; - using Relations = std::tuple, AvmMini_vm::avm_mini>; + using Relations = std::tuple, AvmMini_vm::mem_trace>; static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); @@ -178,11 +178,11 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, - memTrace_m_val_shift, + avmMini_internal_return_ptr_shift, + avmMini_pc_shift, memTrace_m_rw_shift, memTrace_m_addr_shift, - avmMini_pc_shift, - avmMini_internal_return_ptr_shift) + memTrace_m_val_shift) RefVector get_wires() { @@ -218,11 +218,11 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, - memTrace_m_val_shift, + avmMini_internal_return_ptr_shift, + avmMini_pc_shift, memTrace_m_rw_shift, memTrace_m_addr_shift, - avmMini_pc_shift, - avmMini_internal_return_ptr_shift }; + memTrace_m_val_shift }; }; RefVector get_unshifted() { @@ -261,15 +261,15 @@ class AvmMiniFlavor { }; RefVector get_to_be_shifted() { - return { memTrace_m_val, memTrace_m_rw, memTrace_m_addr, avmMini_pc, avmMini_internal_return_ptr }; + return { avmMini_internal_return_ptr, avmMini_pc, memTrace_m_rw, memTrace_m_addr, memTrace_m_val }; }; RefVector get_shifted() { - return { memTrace_m_val_shift, + return { avmMini_internal_return_ptr_shift, + avmMini_pc_shift, memTrace_m_rw_shift, memTrace_m_addr_shift, - avmMini_pc_shift, - avmMini_internal_return_ptr_shift }; + memTrace_m_val_shift }; }; }; @@ -282,7 +282,7 @@ class AvmMiniFlavor { RefVector get_to_be_shifted() { - return { memTrace_m_val, memTrace_m_rw, memTrace_m_addr, avmMini_pc, avmMini_internal_return_ptr }; + return { avmMini_internal_return_ptr, avmMini_pc, memTrace_m_rw, memTrace_m_addr, memTrace_m_val }; }; // The plookup wires that store plookup read data. diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index 2c09cbcc1115..2f8c1f6c60fc 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -535,7 +535,12 @@ std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSi return returnMem; } -// TODO: doc +/** + * @brief HALT opcode + * This opcode effectively stops program execution, and is used in the relation that + * ensures the program counter increments on each opcode. + * i.e. the program counter should freeze and the halt flag is set to 1. + */ void AvmMiniTraceBuilder::halt() { auto clk = mainTrace.size(); @@ -548,15 +553,30 @@ void AvmMiniTraceBuilder::halt() }); } +/** + * @brief INTERNAL_CALL OPCODE + * This opcode effectively jumps to a new `jumpDest` and stores the return program counter + * (current program counter + 1) onto a call stack. + * This function must: + * - Set the next program counter to the provided `jmpDest`. + * - Store the current `pc` + 1 onto the call stack (emulated in memory) + * - Increment the return stack pointer ( a pointer to where the call stack is in memory ) + * + * Note: We use intermediate register a to perform memory storage operations. + * + * @param jmpDest - The destination to jump to + */ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) { auto clk = mainTrace.size(); + // We store the next instruction as the return location uint32_t stored_pc = pc + 1; internal_call_stack.push(stored_pc); - // We want to write the current pc to the memory location pointed by + // Add the return location to the memory trace storeAInMemTrace(internal_return_ptr, FF(stored_pc)); + ffMemory.at(internal_return_ptr) = stored_pc; mainTrace.push_back(Row{ .avmMini_clk = clk, @@ -569,12 +589,21 @@ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) .avmMini_mem_idx_a = FF(internal_return_ptr), }); - // We want the next row to be the one pointed by jmpDest - ffMemory.at(internal_return_ptr) = stored_pc; + // Adjust parameters for the next row pc = jmpDest; internal_return_ptr++; } +/** + * @brief INTERNAL_RETURN OPCODE + * The opcode returns from an internal call. + * This function must: + * - Read the return location from the internal_return_ptr + * - Set the next program counter to the return location + * - Decrement the return stack pointer + * + * TODO(ISSUENUMBER): This function must come after a call instruction. + */ void AvmMiniTraceBuilder::internal_return() { auto clk = mainTrace.size(); diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp index 8904c0145dc5..463bbc466f56 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp @@ -51,11 +51,11 @@ template struct AvmMiniFullRow { FF avmMini_mem_idx_b{}; FF avmMini_mem_idx_c{}; FF avmMini_last{}; - FF memTrace_m_val_shift{}; + FF avmMini_internal_return_ptr_shift{}; + FF avmMini_pc_shift{}; FF memTrace_m_rw_shift{}; FF memTrace_m_addr_shift{}; - FF avmMini_pc_shift{}; - FF avmMini_internal_return_ptr_shift{}; + FF memTrace_m_val_shift{}; }; class AvmMiniCircuitBuilder { @@ -119,11 +119,11 @@ class AvmMiniCircuitBuilder { polys.avmMini_last[i] = rows[i].avmMini_last; } - polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); + polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); + polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); - polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); - polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); + polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); return polys; } @@ -161,14 +161,14 @@ class AvmMiniCircuitBuilder { return true; }; - if (!evaluate_relation.template operator()>( - "mem_trace", AvmMini_vm::get_relation_label_mem_trace)) { - return false; - } if (!evaluate_relation.template operator()>("avm_mini", AvmMini_vm::get_relation_label_avm_mini)) { return false; } + if (!evaluate_relation.template operator()>( + "mem_trace", AvmMini_vm::get_relation_label_mem_trace)) { + return false; + } return true; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp index 99ca3ad99881..2c6a070174b8 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp @@ -7,43 +7,46 @@ namespace proof_system::AvmMini_vm { template struct Avm_miniRow { - FF avmMini_rwb{}; - FF avmMini_sel_internal_call{}; - FF avmMini_mem_idx_a{}; - FF avmMini_first{}; - FF avmMini_sel_op_mul{}; + FF avmMini_internal_return_ptr_shift{}; FF avmMini_sel_op_sub{}; - FF avmMini_sel_halt{}; - FF avmMini_sel_op_add{}; - FF avmMini_rwa{}; - FF avmMini_mem_op_c{}; - FF avmMini_pc{}; + FF avmMini_sel_op_mul{}; + FF avmMini_sel_internal_call{}; + FF avmMini_sel_internal_return{}; + FF avmMini_rwc{}; FF avmMini_op_err{}; - FF avmMini_mem_op_a{}; - FF avmMini_mem_op_b{}; FF avmMini_sel_op_div{}; - FF avmMini_rwc{}; + FF avmMini_mem_op_b{}; + FF avmMini_rwa{}; FF avmMini_ib{}; - FF avmMini_inv{}; FF avmMini_ia{}; - FF avmMini_pc_shift{}; - FF avmMini_internal_return_ptr_shift{}; FF avmMini_ic{}; - FF avmMini_sel_internal_return{}; + FF avmMini_inv{}; + FF avmMini_sel_op_add{}; + FF avmMini_first{}; + FF avmMini_mem_idx_a{}; + FF avmMini_mem_op_c{}; + FF avmMini_rwb{}; + FF avmMini_pc_shift{}; + FF avmMini_pc{}; + FF avmMini_mem_op_a{}; FF avmMini_internal_return_ptr{}; + FF avmMini_sel_halt{}; }; inline std::string get_relation_label_avm_mini(int index) { switch (index) { - case 27: - return "return_pointer_decrement"; + case 26: + return "RETURN_POINTER_DECREMENT"; - case 22: - return "return_pointer_increment"; + case 31: + return "PC_INCREMENT"; case 32: - return "pc_increment"; + return "INTERNAL_RETURN_POINTER_CONSISTENCY"; + + case 21: + return "RETURN_POINTER_INCREMENT"; } return std::to_string(index); } @@ -53,7 +56,7 @@ template class avm_miniImpl { 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, 4, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, }; template @@ -99,7 +102,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(4); - auto tmp = (avmMini_sel_op_div * (-avmMini_sel_op_div + FF(1))); + auto tmp = (avmMini_sel_internal_call * (-avmMini_sel_internal_call + FF(1))); tmp *= scaling_factor; std::get<4>(evals) += tmp; } @@ -107,7 +110,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(5); - auto tmp = (avmMini_sel_internal_call * (-avmMini_sel_internal_call + FF(1))); + auto tmp = (avmMini_sel_internal_return * (-avmMini_sel_internal_return + FF(1))); tmp *= scaling_factor; std::get<5>(evals) += tmp; } @@ -115,7 +118,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(6); - auto tmp = (avmMini_sel_internal_return * (-avmMini_sel_internal_return + FF(1))); + auto tmp = (avmMini_sel_halt * (-avmMini_sel_halt + FF(1))); tmp *= scaling_factor; std::get<6>(evals) += tmp; } @@ -123,7 +126,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(7); - auto tmp = (avmMini_sel_halt * (-avmMini_sel_halt + FF(1))); + auto tmp = (avmMini_op_err * (-avmMini_op_err + FF(1))); tmp *= scaling_factor; std::get<7>(evals) += tmp; } @@ -131,7 +134,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(8); - auto tmp = (avmMini_op_err * (-avmMini_op_err + FF(1))); + auto tmp = (avmMini_mem_op_a * (-avmMini_mem_op_a + FF(1))); tmp *= scaling_factor; std::get<8>(evals) += tmp; } @@ -139,7 +142,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(9); - auto tmp = (avmMini_mem_op_a * (-avmMini_mem_op_a + FF(1))); + auto tmp = (avmMini_mem_op_b * (-avmMini_mem_op_b + FF(1))); tmp *= scaling_factor; std::get<9>(evals) += tmp; } @@ -147,7 +150,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(10); - auto tmp = (avmMini_mem_op_b * (-avmMini_mem_op_b + FF(1))); + auto tmp = (avmMini_mem_op_c * (-avmMini_mem_op_c + FF(1))); tmp *= scaling_factor; std::get<10>(evals) += tmp; } @@ -155,7 +158,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(11); - auto tmp = (avmMini_mem_op_c * (-avmMini_mem_op_c + FF(1))); + auto tmp = (avmMini_rwa * (-avmMini_rwa + FF(1))); tmp *= scaling_factor; std::get<11>(evals) += tmp; } @@ -163,7 +166,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(12); - auto tmp = (avmMini_rwa * (-avmMini_rwa + FF(1))); + auto tmp = (avmMini_rwb * (-avmMini_rwb + FF(1))); tmp *= scaling_factor; std::get<12>(evals) += tmp; } @@ -171,7 +174,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(13); - auto tmp = (avmMini_rwb * (-avmMini_rwb + FF(1))); + auto tmp = (avmMini_rwc * (-avmMini_rwc + FF(1))); tmp *= scaling_factor; std::get<13>(evals) += tmp; } @@ -179,7 +182,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(14); - auto tmp = (avmMini_rwc * (-avmMini_rwc + FF(1))); + auto tmp = (avmMini_sel_op_add * ((avmMini_ia + avmMini_ib) - avmMini_ic)); tmp *= scaling_factor; std::get<14>(evals) += tmp; } @@ -187,7 +190,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(15); - auto tmp = (avmMini_sel_op_add * ((avmMini_ia + avmMini_ib) - avmMini_ic)); + auto tmp = (avmMini_sel_op_sub * ((avmMini_ia - avmMini_ib) - avmMini_ic)); tmp *= scaling_factor; std::get<15>(evals) += tmp; } @@ -195,7 +198,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(16); - auto tmp = (avmMini_sel_op_sub * ((avmMini_ia - avmMini_ib) - avmMini_ic)); + auto tmp = (avmMini_sel_op_mul * ((avmMini_ia * avmMini_ib) - avmMini_ic)); tmp *= scaling_factor; std::get<16>(evals) += tmp; } @@ -203,7 +206,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(17); - auto tmp = (avmMini_sel_op_mul * ((avmMini_ia * avmMini_ib) - avmMini_ic)); + auto tmp = ((avmMini_sel_op_div * (-avmMini_op_err + FF(1))) * ((avmMini_ic * avmMini_ib) - avmMini_ia)); tmp *= scaling_factor; std::get<17>(evals) += tmp; } @@ -211,7 +214,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(18); - auto tmp = ((avmMini_sel_op_div * (-avmMini_op_err + FF(1))) * ((avmMini_ic * avmMini_ib) - avmMini_ia)); + auto tmp = (avmMini_sel_op_div * (((avmMini_ib * avmMini_inv) - FF(1)) + avmMini_op_err)); tmp *= scaling_factor; std::get<18>(evals) += tmp; } @@ -219,7 +222,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(19); - auto tmp = (avmMini_sel_op_div * (((avmMini_ib * avmMini_inv) - FF(1)) + avmMini_op_err)); + auto tmp = ((avmMini_sel_op_div * avmMini_op_err) * (-avmMini_inv + FF(1))); tmp *= scaling_factor; std::get<19>(evals) += tmp; } @@ -227,7 +230,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(20); - auto tmp = ((avmMini_sel_op_div * avmMini_op_err) * (-avmMini_inv + FF(1))); + auto tmp = (avmMini_op_err * (avmMini_sel_op_div - FF(1))); tmp *= scaling_factor; std::get<20>(evals) += tmp; } @@ -235,7 +238,8 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(21); - auto tmp = (avmMini_op_err * (avmMini_sel_op_div - FF(1))); + auto tmp = (avmMini_sel_internal_call * + (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr + FF(1)))); tmp *= scaling_factor; std::get<21>(evals) += tmp; } @@ -243,8 +247,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(22); - auto tmp = (avmMini_sel_internal_call * - (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr + FF(1)))); + auto tmp = (avmMini_sel_internal_call * (avmMini_internal_return_ptr - avmMini_mem_idx_a)); tmp *= scaling_factor; std::get<22>(evals) += tmp; } @@ -252,7 +255,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(23); - auto tmp = (avmMini_sel_internal_call * (avmMini_internal_return_ptr - avmMini_mem_idx_a)); + auto tmp = (avmMini_sel_internal_call * ((avmMini_pc + FF(1)) - avmMini_ia)); tmp *= scaling_factor; std::get<23>(evals) += tmp; } @@ -276,7 +279,8 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(26); - auto tmp = (avmMini_sel_internal_call * ((avmMini_pc + FF(1)) - avmMini_ia)); + auto tmp = (avmMini_sel_internal_return * + (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr - FF(1)))); tmp *= scaling_factor; std::get<26>(evals) += tmp; } @@ -284,8 +288,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(27); - auto tmp = (avmMini_sel_internal_return * - (avmMini_internal_return_ptr_shift - (avmMini_internal_return_ptr - FF(1)))); + auto tmp = (avmMini_sel_internal_return * ((avmMini_internal_return_ptr - FF(1)) - avmMini_mem_idx_a)); tmp *= scaling_factor; std::get<27>(evals) += tmp; } @@ -293,7 +296,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(28); - auto tmp = (avmMini_sel_internal_return * ((avmMini_internal_return_ptr - FF(1)) - avmMini_mem_idx_a)); + auto tmp = (avmMini_sel_internal_return * (avmMini_pc_shift - avmMini_ia)); tmp *= scaling_factor; std::get<28>(evals) += tmp; } @@ -301,7 +304,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(29); - auto tmp = (avmMini_sel_internal_return * (avmMini_pc_shift - avmMini_ia)); + auto tmp = (avmMini_sel_internal_return * avmMini_rwa); tmp *= scaling_factor; std::get<29>(evals) += tmp; } @@ -309,7 +312,7 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(30); - auto tmp = (avmMini_sel_internal_return * avmMini_rwa); + auto tmp = (avmMini_sel_internal_return * (avmMini_mem_op_a - FF(1))); tmp *= scaling_factor; std::get<30>(evals) += tmp; } @@ -317,7 +320,9 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(31); - auto tmp = (avmMini_sel_internal_return * (avmMini_mem_op_a - FF(1))); + auto tmp = ((((-avmMini_first + FF(1)) * (-avmMini_sel_halt + FF(1))) * + (((avmMini_sel_op_add + avmMini_sel_op_sub) + avmMini_sel_op_div) + avmMini_sel_op_mul)) * + (avmMini_pc_shift - (avmMini_pc + FF(1)))); tmp *= scaling_factor; std::get<31>(evals) += tmp; } @@ -325,9 +330,10 @@ template class avm_miniImpl { { AvmMini_DECLARE_VIEWS(32); - auto tmp = ((((-avmMini_first + FF(1)) * (-avmMini_sel_halt + FF(1))) * - (((avmMini_sel_op_add + avmMini_sel_op_sub) + avmMini_sel_op_div) + avmMini_sel_op_mul)) * - (avmMini_pc_shift - (avmMini_pc + FF(1)))); + auto tmp = + ((-(((avmMini_first + avmMini_sel_internal_call) + avmMini_sel_internal_return) + avmMini_sel_halt) + + FF(1)) * + (avmMini_internal_return_ptr_shift - avmMini_internal_return_ptr)); tmp *= scaling_factor; std::get<32>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp index d6313bed5a4e..437ba72f821f 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp @@ -34,8 +34,8 @@ [[maybe_unused]] auto avmMini_mem_idx_b = View(new_term.avmMini_mem_idx_b); \ [[maybe_unused]] auto avmMini_mem_idx_c = View(new_term.avmMini_mem_idx_c); \ [[maybe_unused]] auto avmMini_last = View(new_term.avmMini_last); \ - [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ + [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); \ + [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ - [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ - [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); + [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp index 583f698937bc..ab209ad95a5c 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp @@ -7,15 +7,15 @@ namespace proof_system::AvmMini_vm { template struct Mem_traceRow { - FF memTrace_m_lastAccess{}; + FF memTrace_m_addr{}; + FF memTrace_m_rw_shift{}; + FF memTrace_m_addr_shift{}; FF avmMini_last{}; - FF memTrace_m_val_shift{}; FF avmMini_first{}; - FF memTrace_m_rw_shift{}; + FF memTrace_m_lastAccess{}; + FF memTrace_m_val_shift{}; FF memTrace_m_val{}; FF memTrace_m_rw{}; - FF memTrace_m_addr{}; - FF memTrace_m_addr_shift{}; }; inline std::string get_relation_label_mem_trace(int index) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp index 2c224e75c848..452fe0b8d428 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp @@ -3,7 +3,6 @@ #include "barretenberg/numeric/uint256/uint256.hpp" #include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" #include "barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp" -#include "barretenberg/sumcheck/sumcheck_round.hpp" #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" @@ -31,8 +30,6 @@ class AvmMiniControlFlowTests : public ::testing::Test { }; }; -class AvmMiniArithmeticNegativeTests : public AvmMiniControlFlowTests {}; - // We add some helper functions in the anonymous namespace. namespace { @@ -70,6 +67,7 @@ void validateTraceProof(std::vector&& trace) TEST_F(AvmMiniControlFlowTests, simpleCall) { uint32_t const CALL_ADDRESS = 4; + // trace_builder for the following operation // pc opcode // 0 INTERNAL_CALL(pc=4) @@ -79,28 +77,31 @@ TEST_F(AvmMiniControlFlowTests, simpleCall) auto trace = trace_builder.finalize(); - // Find the row of the call - auto call_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_call == FF(1); }); - EXPECT_TRUE(call_row != trace.end()); - EXPECT_EQ(call_row->avmMini_pc, FF(0)); - EXPECT_EQ(call_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); - EXPECT_EQ(call_row->avmMini_ia, FF(1)); - EXPECT_EQ(call_row->avmMini_mem_idx_a, - FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); // Store the return address (0) in memory - - // Find the row of the halt - auto halt_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_halt == FF(1); }); + // Check call + { + auto call_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_call == FF(1); }); + EXPECT_TRUE(call_row != trace.end()); + EXPECT_EQ(call_row->avmMini_pc, FF(0)); + EXPECT_EQ(call_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); + EXPECT_EQ(call_row->avmMini_ia, FF(1)); + EXPECT_EQ(call_row->avmMini_mem_idx_a, + FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); // Store the return address (0) in memory + } - // Check that the correct result is stored at the expected memory location. - EXPECT_TRUE(halt_row != trace.end()); - EXPECT_EQ(halt_row->avmMini_pc, FF(CALL_ADDRESS)); - EXPECT_EQ(halt_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); + // Check halt + { + auto halt_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_halt == FF(1); }); + // Check that the correct result is stored at the expected memory location. + EXPECT_TRUE(halt_row != trace.end()); + EXPECT_EQ(halt_row->avmMini_pc, FF(CALL_ADDRESS)); + EXPECT_EQ(halt_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); + } validateTraceProof(std::move(trace)); } -// Test on basic addition over finite field type. TEST_F(AvmMiniControlFlowTests, simpleCallAndReturn) { uint32_t const CALL_ADDRESS = 20; @@ -116,30 +117,37 @@ TEST_F(AvmMiniControlFlowTests, simpleCallAndReturn) auto trace = trace_builder.finalize(); - // Find the row of the call - auto call_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_call == FF(1); }); - EXPECT_TRUE(call_row != trace.end()); - EXPECT_EQ(call_row->avmMini_pc, FF(0)); - EXPECT_EQ(call_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); - EXPECT_EQ(call_row->avmMini_ia, FF(1)); - EXPECT_EQ(call_row->avmMini_mem_idx_a, - FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); // Store the return address (0) in memory - - // Return row - auto return_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_return == FF(1); }); - - // Check that the correct result is stored at the expected memory location. - EXPECT_TRUE(return_row != trace.end()); - EXPECT_EQ(return_row->avmMini_pc, FF(CALL_ADDRESS)); - EXPECT_EQ(return_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); + // Check call + { + auto call_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_call == FF(1); }); + EXPECT_TRUE(call_row != trace.end()); + EXPECT_EQ(call_row->avmMini_pc, FF(0)); + EXPECT_EQ(call_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); + EXPECT_EQ(call_row->avmMini_ia, FF(1)); + EXPECT_EQ(call_row->avmMini_mem_idx_a, + FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET)); // Store the return address (0) in memory + } + + // Check return + { + auto return_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_internal_return == FF(1); }); - // Halt row - auto halt_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_halt == FF(1); }); + // Check that the correct result is stored at the expected memory location. + EXPECT_TRUE(return_row != trace.end()); + EXPECT_EQ(return_row->avmMini_pc, FF(CALL_ADDRESS)); + EXPECT_EQ(return_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); + } - EXPECT_TRUE(halt_row != trace.end()); - EXPECT_EQ(halt_row->avmMini_pc, FF(RETURN_ADDRESS)); + // Check halt + { + auto halt_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_halt == FF(1); }); + + EXPECT_TRUE(halt_row != trace.end()); + EXPECT_EQ(halt_row->avmMini_pc, FF(RETURN_ADDRESS)); + } validateTraceProof(std::move(trace)); } From b392b2ef6e7fd452a9ffb34bd7472b1c170ca75d Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Tue, 19 Dec 2023 15:57:35 +0000 Subject: [PATCH 09/10] =?UTF-8?q?=F0=9F=A7=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- barretenberg/cpp/pil/avm/avm_mini.pil | 5 +- .../circuit_builder/AvmMini_helper.cpp | 68 +++++++++---------- .../circuit_builder/AvmMini_trace.cpp | 2 +- .../circuit_builder/AvmMini_trace.hpp | 6 +- .../vm/tests/AvmMini_arithmetic.test.cpp | 2 - .../vm/tests/AvmMini_control_flow.test.cpp | 29 +------- 6 files changed, 42 insertions(+), 70 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index fc71158c95d7..dc8d2029584b 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -154,16 +154,17 @@ namespace avmMini(256); // Imply that we must load the return location into mem_idx_a #[RETURN_POINTER_INCREMENT] - sel_internal_call * ( internal_return_ptr' - ( internal_return_ptr + 1)) = 0; // we increment our jump selector + sel_internal_call * ( internal_return_ptr' - ( internal_return_ptr + 1)) = 0; sel_internal_call * ( internal_return_ptr - mem_idx_a) = 0; sel_internal_call * ((pc + 1) - ia) = 0; + // TODO(md): Below relations may be removed through sub-op table lookup sel_internal_call * (rwa - 1) = 0; sel_internal_call * (mem_op_a - 1) = 0; // We must load the memory pointer to be the internal_return_ptr #[RETURN_POINTER_DECREMENT] - sel_internal_return * ( internal_return_ptr' - ( internal_return_ptr - 1)) = 0; // We decrement out jump selector + sel_internal_return * ( internal_return_ptr' - ( internal_return_ptr - 1)) = 0; sel_internal_return * ( (internal_return_ptr - 1) - mem_idx_a) = 0; sel_internal_return * (pc' - ia) = 0; diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp index 9ef701440732..60d92a168cc7 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp @@ -20,23 +20,23 @@ void log_avmMini_trace(std::vector const& trace, size_t beg, size_t end) for (size_t i = beg; i < end; i++) { info("====================================================================================="); - info("== ROW ", i); - info("================================================================================"); + info("== ROW ", i); + info("====================================================================================="); - info("=======MEMORY TRACE============================================================="); - info("m_addr: ", trace.at(i).memTrace_m_addr); - info("m_clk: ", trace.at(i).memTrace_m_clk); - info("m_sub_clk: ", trace.at(i).memTrace_m_sub_clk); - info("m_val: ", trace.at(i).memTrace_m_val); - info("m_rw: ", trace.at(i).memTrace_m_rw); - info("m_tag: ", trace.at(i).memTrace_m_tag); - info("m_in_tag: ", trace.at(i).memTrace_m_in_tag); - info("m_tag_err: ", trace.at(i).memTrace_m_tag_err); - info("m_one_min_inv:", trace.at(i).memTrace_m_one_min_inv); + info("=======MEMORY TRACE=================================================================="); + info("m_addr: ", trace.at(i).memTrace_m_addr); + info("m_clk: ", trace.at(i).memTrace_m_clk); + info("m_sub_clk: ", trace.at(i).memTrace_m_sub_clk); + info("m_val: ", trace.at(i).memTrace_m_val); + info("m_rw: ", trace.at(i).memTrace_m_rw); + info("m_tag: ", trace.at(i).memTrace_m_tag); + info("m_in_tag: ", trace.at(i).memTrace_m_in_tag); + info("m_tag_err: ", trace.at(i).memTrace_m_tag_err); + info("m_one_min_inv: ", trace.at(i).memTrace_m_one_min_inv); - info("m_lastAccess: ", trace.at(i).memTrace_m_lastAccess); - info("m_last: ", trace.at(i).memTrace_m_last); - info("m_val_shift: ", trace.at(i).memTrace_m_val_shift); + info("m_lastAccess: ", trace.at(i).memTrace_m_lastAccess); + info("m_last: ", trace.at(i).memTrace_m_last); + info("m_val_shift: ", trace.at(i).memTrace_m_val_shift); info("=======CONTROL_FLOW==================================================================="); info("pc: ", trace.at(i).avmMini_pc); @@ -44,28 +44,28 @@ void log_avmMini_trace(std::vector const& trace, size_t beg, size_t end) info("internal_return: ", trace.at(i).avmMini_sel_internal_return); info("internal_return_ptr:", trace.at(i).avmMini_internal_return_ptr); - info("=======MAIN TRACE==============================================================="); - info("ia: ", trace.at(i).avmMini_ia); - info("ib: ", trace.at(i).avmMini_ib); - info("ic: ", trace.at(i).avmMini_ic); - info("first: ", trace.at(i).avmMini_first); - info("last: ", trace.at(i).avmMini_last); + info("=======MAIN TRACE===================================================================="); + info("ia: ", trace.at(i).avmMini_ia); + info("ib: ", trace.at(i).avmMini_ib); + info("ic: ", trace.at(i).avmMini_ic); + info("first: ", trace.at(i).avmMini_first); + info("last: ", trace.at(i).avmMini_last); - info("=======MEM_OP_A================================================================="); - info("clk: ", trace.at(i).avmMini_clk); - info("mem_op_a: ", trace.at(i).avmMini_mem_op_a); - info("mem_idx_a: ", trace.at(i).avmMini_mem_idx_a); - info("rwa: ", trace.at(i).avmMini_rwa); + info("=======MEM_OP_A======================================================================"); + info("clk: ", trace.at(i).avmMini_clk); + info("mem_op_a: ", trace.at(i).avmMini_mem_op_a); + info("mem_idx_a: ", trace.at(i).avmMini_mem_idx_a); + info("rwa: ", trace.at(i).avmMini_rwa); - info("=======MEM_OP_B================================================================="); - info("mem_op_b: ", trace.at(i).avmMini_mem_op_b); - info("mem_idx_b: ", trace.at(i).avmMini_mem_idx_b); - info("rwb: ", trace.at(i).avmMini_rwb); + info("=======MEM_OP_B======================================================================"); + info("mem_op_b: ", trace.at(i).avmMini_mem_op_b); + info("mem_idx_b: ", trace.at(i).avmMini_mem_idx_b); + info("rwb: ", trace.at(i).avmMini_rwb); - info("=======MEM_OP_C================================================================="); - info("mem_op_c: ", trace.at(i).avmMini_mem_op_c); - info("mem_idx_c: ", trace.at(i).avmMini_mem_idx_c); - info("rwc: ", trace.at(i).avmMini_rwc); + info("=======MEM_OP_C======================================================================"); + info("mem_op_c: ", trace.at(i).avmMini_mem_op_c); + info("mem_idx_c: ", trace.at(i).avmMini_mem_idx_c); + info("rwc: ", trace.at(i).avmMini_rwc); info("\n"); } } diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index 56c8fa1ef1af..c2e4137f0a7c 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -615,7 +615,7 @@ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) * - Set the next program counter to the return location * - Decrement the return stack pointer * - * TODO(ISSUENUMBER): This function must come after a call instruction. + * TODO(https://github.com/AztecProtocol/aztec-packages/issues/3740): This function MUST come after a call instruction. */ void AvmMiniTraceBuilder::internal_return() { diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp index 3da0457e050f..f7dd66f3b3e2 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp @@ -30,7 +30,7 @@ class AvmMiniTraceBuilder { // Number of rows static const size_t N = 256; static const size_t MEM_SIZE = 1024; - static const size_t CALLSTACK_OFFSET = 896; // TODO is this the vibe - i assume not + static const size_t CALLSTACK_OFFSET = 896; // TODO(md): Temporary reserved area 896 - 1024 static const uint32_t SUB_CLK_LOAD_A = 0; static const uint32_t SUB_CLK_LOAD_B = 1; @@ -60,7 +60,7 @@ class AvmMiniTraceBuilder { void div(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag); // Jump to a given program counter. - // TODO: this program counter MUST be an operand to the OPCODE. + // TODO(md): this program counter MUST be an operand to the OPCODE. void internal_call(uint32_t jmpDest); // Return from a jump. @@ -98,7 +98,7 @@ class AvmMiniTraceBuilder { uint32_t pc = 0; uint32_t internal_return_ptr = CALLSTACK_OFFSET; - std::stack internal_call_stack; // TODO: initialize + std::stack internal_call_stack = {}; static bool compareMemEntries(const MemoryTraceEntry& left, const MemoryTraceEntry& right); void insertInMemTrace( diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp index c24b419d2746..a75e798292c3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp @@ -69,8 +69,6 @@ TEST_F(AvmMiniArithmeticTests, additionFF) trace_builder.returnOP(0, 5); auto trace = trace_builder.finalize(); - info("Built circuit with ", trace.size(), " rows"); - // Find the first row enabling the addition selector auto row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avmMini_sel_op_add == FF(1); }); diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp index 452fe0b8d428..376f7ed1e5fc 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp @@ -6,6 +6,7 @@ #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" +#include "helpers.test.hpp" #include #include @@ -30,34 +31,6 @@ class AvmMiniControlFlowTests : public ::testing::Test { }; }; -// We add some helper functions in the anonymous namespace. -namespace { - -/** - * @brief Helper routine proving and verifying a proof based on the supplied trace - * - * @param trace The execution trace - */ -void validateTraceProof(std::vector&& trace) -{ - auto circuit_builder = AvmMiniCircuitBuilder(); - circuit_builder.set_trace(std::move(trace)); - - EXPECT_TRUE(circuit_builder.check_circuit()); - - auto composer = honk::AvmMiniComposer(); - auto prover = composer.create_prover(circuit_builder); - auto proof = prover.construct_proof(); - - auto verifier = composer.create_verifier(circuit_builder); - bool verified = verifier.verify_proof(proof); - - if (!verified) { - log_avmMini_trace(circuit_builder.rows, 0, 10); - } -}; -} // anonymous namespace - /****************************************************************************** * * POSITIVE TESTS - Control Flow From 4e54074ef56defe7c82489ac92c5ba36ac0554f6 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Tue, 19 Dec 2023 16:44:58 +0000 Subject: [PATCH 10/10] =?UTF-8?q?=F0=9F=A7=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- barretenberg/cpp/pil/avm/avm_mini.pil | 3 +- .../flavor/generated/AvmMini_flavor.hpp | 36 +++++----- .../circuit_builder/AvmMini_trace.cpp | 6 +- .../generated/AvmMini_circuit_builder.hpp | 24 +++---- .../relations/generated/AvmMini/avm_mini.hpp | 72 +++++++++---------- .../generated/AvmMini/declare_views.hpp | 8 +-- .../relations/generated/AvmMini/mem_trace.hpp | 24 +++---- 7 files changed, 88 insertions(+), 85 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_mini.pil b/barretenberg/cpp/pil/avm/avm_mini.pil index dc8d2029584b..b2e10e30cca0 100644 --- a/barretenberg/cpp/pil/avm/avm_mini.pil +++ b/barretenberg/cpp/pil/avm/avm_mini.pil @@ -172,7 +172,7 @@ namespace avmMini(256); sel_internal_return * rwa = 0; sel_internal_return * (mem_op_a - 1) = 0; - //===== CONTROL_FLOW_CONSITENCY ============================================ + //===== CONTROL_FLOW_CONSISTENCY ============================================ pol CONTROL_FLOW_SELECTORS = (first + sel_internal_call + sel_internal_return + sel_halt); pol OPCODE_SELECTORS = (sel_op_add + sel_op_sub + sel_op_div + sel_op_mul); @@ -180,6 +180,7 @@ namespace avmMini(256); #[PC_INCREMENT] (1 - first) * (1 - sel_halt) * OPCODE_SELECTORS * (pc' - (pc + 1)) = 0; + // first == 0 && sel_internal_call == 0 && sel_internal_return == 0 && sel_halt == 0 ==> internal_return_ptr == internal_return_ptr' #[INTERNAL_RETURN_POINTER_CONSISTENCY] (1 - CONTROL_FLOW_SELECTORS) * (internal_return_ptr' - internal_return_ptr) = 0; diff --git a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp index 42525cec4f8a..d9b5edb8c61c 100644 --- a/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/flavor/generated/AvmMini_flavor.hpp @@ -42,7 +42,7 @@ class AvmMiniFlavor { // the unshifted and one for the shifted static constexpr size_t NUM_ALL_ENTITIES = 45; - using Relations = std::tuple, AvmMini_vm::avm_mini>; + using Relations = std::tuple, AvmMini_vm::mem_trace>; static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); @@ -199,12 +199,12 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, - memTrace_m_val_shift, + avmMini_internal_return_ptr_shift, + avmMini_pc_shift, memTrace_m_tag_shift, - memTrace_m_addr_shift, + memTrace_m_val_shift, memTrace_m_rw_shift, - avmMini_internal_return_ptr_shift, - avmMini_pc_shift) + memTrace_m_addr_shift) RefVector get_wires() { @@ -247,12 +247,12 @@ class AvmMiniFlavor { avmMini_mem_idx_b, avmMini_mem_idx_c, avmMini_last, - memTrace_m_val_shift, + avmMini_internal_return_ptr_shift, + avmMini_pc_shift, memTrace_m_tag_shift, - memTrace_m_addr_shift, + memTrace_m_val_shift, memTrace_m_rw_shift, - avmMini_internal_return_ptr_shift, - avmMini_pc_shift }; + memTrace_m_addr_shift }; }; RefVector get_unshifted() { @@ -298,17 +298,18 @@ class AvmMiniFlavor { }; RefVector get_to_be_shifted() { - return { memTrace_m_val, memTrace_m_tag, memTrace_m_addr, memTrace_m_rw, avmMini_internal_return_ptr, - avmMini_pc }; + return { + avmMini_internal_return_ptr, avmMini_pc, memTrace_m_tag, memTrace_m_val, memTrace_m_rw, memTrace_m_addr + }; }; RefVector get_shifted() { - return { memTrace_m_val_shift, + return { avmMini_internal_return_ptr_shift, + avmMini_pc_shift, memTrace_m_tag_shift, - memTrace_m_addr_shift, + memTrace_m_val_shift, memTrace_m_rw_shift, - avmMini_internal_return_ptr_shift, - avmMini_pc_shift }; + memTrace_m_addr_shift }; }; }; @@ -321,8 +322,9 @@ class AvmMiniFlavor { RefVector get_to_be_shifted() { - return { memTrace_m_val, memTrace_m_tag, memTrace_m_addr, memTrace_m_rw, avmMini_internal_return_ptr, - avmMini_pc }; + return { + avmMini_internal_return_ptr, avmMini_pc, memTrace_m_tag, memTrace_m_val, memTrace_m_rw, memTrace_m_addr + }; }; // The plookup wires that store plookup read data. diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index c2e4137f0a7c..9c6721160f8b 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -568,14 +568,14 @@ void AvmMiniTraceBuilder::halt() /** * @brief INTERNAL_CALL OPCODE - * This opcode effectively jumps to a new `jumpDest` and stores the return program counter + * This opcode effectively jumps to a new `jmpDest` and stores the return program counter * (current program counter + 1) onto a call stack. * This function must: * - Set the next program counter to the provided `jmpDest`. * - Store the current `pc` + 1 onto the call stack (emulated in memory) - * - Increment the return stack pointer ( a pointer to where the call stack is in memory ) + * - Increment the return stack pointer (a pointer to where the call stack is in memory) * - * Note: We use intermediate register a to perform memory storage operations. + * Note: We use intermediate register to perform memory storage operations. * * @param jmpDest - The destination to jump to */ diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp index ce7a80ad85c2..a41fb694b9c5 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp @@ -58,12 +58,12 @@ template struct AvmMiniFullRow { FF avmMini_mem_idx_b{}; FF avmMini_mem_idx_c{}; FF avmMini_last{}; - FF memTrace_m_val_shift{}; - FF memTrace_m_tag_shift{}; - FF memTrace_m_addr_shift{}; - FF memTrace_m_rw_shift{}; FF avmMini_internal_return_ptr_shift{}; FF avmMini_pc_shift{}; + FF memTrace_m_tag_shift{}; + FF memTrace_m_val_shift{}; + FF memTrace_m_rw_shift{}; + FF memTrace_m_addr_shift{}; }; class AvmMiniCircuitBuilder { @@ -134,12 +134,12 @@ class AvmMiniCircuitBuilder { polys.avmMini_last[i] = rows[i].avmMini_last; } - polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); - polys.memTrace_m_tag_shift = Polynomial(polys.memTrace_m_tag.shifted()); - polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); - polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); polys.avmMini_internal_return_ptr_shift = Polynomial(polys.avmMini_internal_return_ptr.shifted()); polys.avmMini_pc_shift = Polynomial(polys.avmMini_pc.shifted()); + polys.memTrace_m_tag_shift = Polynomial(polys.memTrace_m_tag.shifted()); + polys.memTrace_m_val_shift = Polynomial(polys.memTrace_m_val.shifted()); + polys.memTrace_m_rw_shift = Polynomial(polys.memTrace_m_rw.shifted()); + polys.memTrace_m_addr_shift = Polynomial(polys.memTrace_m_addr.shifted()); return polys; } @@ -177,14 +177,14 @@ class AvmMiniCircuitBuilder { return true; }; - if (!evaluate_relation.template operator()>( - "mem_trace", AvmMini_vm::get_relation_label_mem_trace)) { - return false; - } if (!evaluate_relation.template operator()>("avm_mini", AvmMini_vm::get_relation_label_avm_mini)) { return false; } + if (!evaluate_relation.template operator()>( + "mem_trace", AvmMini_vm::get_relation_label_mem_trace)) { + return false; + } return true; } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp index 624905b57c9f..46d9a5bc9e95 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/avm_mini.hpp @@ -7,31 +7,31 @@ namespace proof_system::AvmMini_vm { template struct Avm_miniRow { - FF avmMini_rwb{}; - FF avmMini_mem_op_c{}; - FF avmMini_ia{}; - FF avmMini_internal_return_ptr_shift{}; - FF avmMini_first{}; - FF avmMini_sel_internal_call{}; - FF avmMini_pc{}; - FF avmMini_sel_op_sub{}; - FF avmMini_sel_halt{}; - FF avmMini_rwc{}; + FF avmMini_rwa{}; FF avmMini_sel_op_div{}; - FF avmMini_ic{}; FF avmMini_inv{}; - FF avmMini_tag_err{}; - FF avmMini_sel_op_mul{}; - FF avmMini_pc_shift{}; - FF avmMini_sel_internal_return{}; - FF avmMini_mem_idx_a{}; - FF avmMini_rwa{}; FF avmMini_internal_return_ptr{}; - FF avmMini_mem_op_a{}; - FF avmMini_ib{}; + FF avmMini_sel_internal_call{}; + FF avmMini_ic{}; + FF avmMini_rwb{}; + FF avmMini_sel_halt{}; FF avmMini_sel_op_add{}; FF avmMini_mem_op_b{}; FF avmMini_op_err{}; + FF avmMini_rwc{}; + FF avmMini_ib{}; + FF avmMini_mem_idx_a{}; + FF avmMini_sel_op_sub{}; + FF avmMini_sel_op_mul{}; + FF avmMini_ia{}; + FF avmMini_internal_return_ptr_shift{}; + FF avmMini_pc{}; + FF avmMini_pc_shift{}; + FF avmMini_tag_err{}; + FF avmMini_mem_op_c{}; + FF avmMini_mem_op_a{}; + FF avmMini_sel_internal_return{}; + FF avmMini_first{}; }; inline std::string get_relation_label_avm_mini(int index) @@ -43,32 +43,32 @@ inline std::string get_relation_label_avm_mini(int index) case 22: return "SUBOP_DIVISION_ZERO_ERR1"; - case 30: - return "RETURN_POINTER_DECREMENT"; - - case 21: - return "SUBOP_DIVISION_FF"; - - case 18: - return "SUBOP_ADDITION_FF"; - - case 36: - return "INTERNAL_RETURN_POINTER_CONSISTENCY"; + case 23: + return "SUBOP_DIVISION_ZERO_ERR2"; - case 19: - return "SUBOP_SUBTRACTION_FF"; + case 24: + return "SUBOP_ERROR_RELEVANT_OP"; case 25: return "RETURN_POINTER_INCREMENT"; + case 30: + return "RETURN_POINTER_DECREMENT"; + case 35: return "PC_INCREMENT"; - case 24: - return "SUBOP_ERROR_RELEVANT_OP"; + case 19: + return "SUBOP_SUBTRACTION_FF"; - case 23: - return "SUBOP_DIVISION_ZERO_ERR2"; + case 21: + return "SUBOP_DIVISION_FF"; + + case 36: + return "INTERNAL_RETURN_POINTER_CONSISTENCY"; + + case 18: + return "SUBOP_ADDITION_FF"; } return std::to_string(index); } diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp index 86771c67c357..0c711d834290 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/declare_views.hpp @@ -41,9 +41,9 @@ [[maybe_unused]] auto avmMini_mem_idx_b = View(new_term.avmMini_mem_idx_b); \ [[maybe_unused]] auto avmMini_mem_idx_c = View(new_term.avmMini_mem_idx_c); \ [[maybe_unused]] auto avmMini_last = View(new_term.avmMini_last); \ - [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ + [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); \ + [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); \ [[maybe_unused]] auto memTrace_m_tag_shift = View(new_term.memTrace_m_tag_shift); \ - [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); \ + [[maybe_unused]] auto memTrace_m_val_shift = View(new_term.memTrace_m_val_shift); \ [[maybe_unused]] auto memTrace_m_rw_shift = View(new_term.memTrace_m_rw_shift); \ - [[maybe_unused]] auto avmMini_internal_return_ptr_shift = View(new_term.avmMini_internal_return_ptr_shift); \ - [[maybe_unused]] auto avmMini_pc_shift = View(new_term.avmMini_pc_shift); + [[maybe_unused]] auto memTrace_m_addr_shift = View(new_term.memTrace_m_addr_shift); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp index 3dbc9244f89b..2adc17baf9fb 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/AvmMini/mem_trace.hpp @@ -7,39 +7,39 @@ namespace proof_system::AvmMini_vm { template struct Mem_traceRow { + FF memTrace_m_tag_shift{}; FF memTrace_m_tag{}; + FF memTrace_m_rw{}; FF memTrace_m_lastAccess{}; FF memTrace_m_last{}; FF memTrace_m_tag_err{}; - FF memTrace_m_addr{}; - FF memTrace_m_val_shift{}; - FF memTrace_m_rw{}; FF memTrace_m_val{}; - FF memTrace_m_tag_shift{}; - FF memTrace_m_in_tag{}; - FF memTrace_m_addr_shift{}; FF memTrace_m_one_min_inv{}; + FF memTrace_m_val_shift{}; + FF memTrace_m_addr{}; FF memTrace_m_rw_shift{}; + FF memTrace_m_addr_shift{}; + FF memTrace_m_in_tag{}; }; inline std::string get_relation_label_mem_trace(int index) { switch (index) { + case 5: + return "MEM_READ_WRITE_VAL_CONSISTENCY"; + case 7: return "MEM_ZERO_INIT"; + case 9: + return "MEM_IN_TAG_CONSISTENCY_2"; + case 8: return "MEM_IN_TAG_CONSISTENCY_1"; - case 5: - return "MEM_READ_WRITE_VAL_CONSISTENCY"; - case 4: return "MEM_LAST_ACCESS_DELIMITER"; - case 9: - return "MEM_IN_TAG_CONSISTENCY_2"; - case 6: return "MEM_READ_WRITE_TAG_CONSISTENCY"; }