From 885313281c110dc47946586e590ce46504ffa6d8 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Wed, 3 Apr 2024 15:47:35 +0000 Subject: [PATCH 1/6] avm_logderivative --- .../barretenberg/vm/generated/avm_flavor.hpp | 59 +++++++++++++++++++ .../barretenberg/vm/generated/avm_prover.cpp | 34 ++++++++++- .../barretenberg/vm/generated/avm_prover.hpp | 1 + docs/package.json | 10 ++-- 4 files changed, 96 insertions(+), 8 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 0c2f9abe7f8..5814cb14c53 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -52,6 +52,16 @@ class AvmFlavor { // the unshifted and one for the shifted static constexpr size_t NUM_ALL_ENTITIES = 159; + // TODO: what for? + using GrandProductRelations = std::tuple, + perm_main_bin_relation, + perm_main_mem_a_relation, + perm_main_mem_b_relation, + perm_main_mem_c_relation, + perm_main_mem_ind_a_relation, + perm_main_mem_ind_b_relation, + perm_main_mem_ind_c_relation>; + using Relations = std::tuple, Avm_vm::avm_binary, Avm_vm::avm_main, @@ -899,6 +909,41 @@ class AvmFlavor { // The plookup wires that store plookup read data. std::array get_table_column_wires() { return {}; }; + + void compute_logderivative_inverses(const RelationParameters& relation_parameters) + { + ProverPolynomials prover_polynomials = ProverPolynomials(*this); + + // perm_main_alu_relation, + // perm_main_bin_relation, + // perm_main_mem_a_relation, + // perm_main_mem_b_relation, + // perm_main_mem_c_relation, + // perm_main_mem_ind_a_relation, + // perm_main_mem_ind_b_relation, + // perm_main_mem_ind_c_relation>; + + // One of these for each + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + + // TODO: check if this has set the inverse for each of the polys + info("Computed logderivative inverses for all relations"); + } }; using VerificationKey = VerificationKey_, VerifierCommitmentKey>; @@ -923,6 +968,20 @@ class AvmFlavor { ProverPolynomials(ProverPolynomials&& o) noexcept = default; ProverPolynomials& operator=(ProverPolynomials&& o) noexcept = default; ~ProverPolynomials() = default; + + // NOTE: copied from goblin ultra + ProverPolynomials(ProvingKey& proving_key) + { + for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key.get_all())) { + ASSERT(flavor_get_label(*this, prover_poly) == flavor_get_label(proving_key, key_poly)); + prover_poly = key_poly.share(); + } + for (auto [prover_poly, key_poly] : zip_view(this->get_shifted(), proving_key.get_to_be_shifted())) { + ASSERT(flavor_get_label(*this, prover_poly) == (flavor_get_label(proving_key, key_poly) + "_shift")); + prover_poly = key_poly.shifted(); + } + } + [[nodiscard]] size_t get_polynomial_size() const { return avm_alu_alu_sel.size(); } /** * @brief Returns the evaluations of all prover polynomials at one point on the boolean hypercube, which diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index e887045bb96..3968cf5b6b7 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -63,6 +63,35 @@ void AvmProver::execute_wire_commitments_round() } } +void AvmProver::execute_log_derivative_inverse_round() +{ + auto [beta, gamma] = transcript->template get_challenges("beta", "gamma"); + relation_parameters.beta = beta; + relation_parameters.gamma = gamma; + + // TODO: Add an implementation of this to the flavor + // We will need to compute -> the inverse for each column and add it to the proving key + // -> I think we should be able to use each of the bespoke lookup relations for this??? + // -> + // snippet is below + /** + void compute_logderivative_inverse(const RelationParameters& relation_parameters) + { + auto prover_polynomials = ProverPolynomials(*this); + // Compute permutation and lookup grand product polynomials + bb::compute_logderivative_inverse( + prover_polynomials, relation_parameters, this->circuit_size); + this->lookup_inverses = prover_polynomials.lookup_inverses; + } + */ + + key->compute_logderivative_inverses(relation_parameters); + // Add commitments for each below + // witness_commitments.lookup_inverses = commitment_key->commit(proving_key.lookup_inverses); + // transcript->send_to_verifier(domain_separator + commitment_labels.lookup_inverses, + // witness_commitments.lookup_inverses); +} + /** * @brief Run Sumcheck resulting in u = (u_1,...,u_d) challenges and all evaluations at u being calculated. * @@ -112,13 +141,12 @@ HonkProof& AvmProver::construct_proof() // Compute wire commitments execute_wire_commitments_round(); - // TODO: not implemented for codegen just yet // Compute sorted list accumulator and commitment - // execute_log_derivative_commitments_round(); + execute_log_derivative_commitments_round(); // Fiat-Shamir: bbeta & gamma // Compute grand product(s) and commitments. - // execute_grand_product_computation_round(); + execute_grand_product_computation_round(); // Fiat-Shamir: alpha // Run sumcheck subprotocol. diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp index 1e15b341e17..324373fa7cc 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp @@ -28,6 +28,7 @@ class AvmProver { void execute_preamble_round(); void execute_wire_commitments_round(); + void execute_log_derivative_inverse_round(); void execute_relation_check_rounds(); void execute_zeromorph_rounds(); diff --git a/docs/package.json b/docs/package.json index 67a53d63e89..53e11c4e588 100644 --- a/docs/package.json +++ b/docs/package.json @@ -20,10 +20,10 @@ "write-heading-ids": "docusaurus write-heading-ids" }, "dependencies": { - "@docusaurus/core": "^2.4.1", - "@docusaurus/plugin-ideal-image": "^2.4.1", - "@docusaurus/preset-classic": "^2.4.1", - "@docusaurus/theme-mermaid": "^2.4.1", + "@docusaurus/core": "^3.2.0", + "@docusaurus/plugin-ideal-image": "^3.2.0", + "@docusaurus/preset-classic": "^3.2.0", + "@docusaurus/theme-mermaid": "^3.2.0", "@mdx-js/react": "^1.6.22", "axios": "^1.4.0", "clsx": "^1.1.1", @@ -32,7 +32,7 @@ "react": "^17.0.2", "react-dom": "^17.0.2", "react-player": "^2.12.0", - "rehype-katex": "5", + "rehype-katex": "^7.0.0", "remark-math": "3" }, "devDependencies": { From abc3cba9a0af2ef325f6bc4294eb15c7d5906969 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 4 Apr 2024 18:01:25 +0000 Subject: [PATCH 2/6] temp: chall line up --- .../src/barretenberg/sumcheck/sumcheck.hpp | 1 + .../barretenberg/ultra_honk/ultra_prover.cpp | 1 + .../vm/generated/avm_circuit_builder.hpp | 12 +- .../vm/generated/avm_composer.cpp | 3 +- .../vm/generated/avm_composer.hpp | 3 +- .../barretenberg/vm/generated/avm_flavor.hpp | 222 ++++++++++- .../barretenberg/vm/generated/avm_prover.cpp | 357 ++++++++++++++++-- .../barretenberg/vm/generated/avm_prover.hpp | 1 + .../vm/generated/avm_verifier.cpp | 41 +- .../barretenberg/vm/tests/helpers.test.cpp | 37 +- 10 files changed, 622 insertions(+), 56 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp index 3e5a3461a85..2ff1721a9c8 100644 --- a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp +++ b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp @@ -122,6 +122,7 @@ template class SumcheckProver { zip_view(multivariate_evaluations.get_all(), partially_evaluated_polynomials.get_all())) { eval = poly[0]; } + info("Multivariate evaluations: {}", multivariate_evaluations.get_all().size()); transcript->send_to_verifier("Sumcheck:evaluations", multivariate_evaluations.get_all()); return { multivariate_challenge, multivariate_evaluations }; diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp index f3fc6b0e5be..76c4843d4f5 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp @@ -45,6 +45,7 @@ template void UltraProver_::execute_relation_chec std::vector gate_challenges(numeric::get_msb(circuit_size)); for (size_t idx = 0; idx < gate_challenges.size(); idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); + info("gate_challenges[", idx, "] = ", gate_challenges[idx]); } instance->gate_challenges = gate_challenges; sumcheck_output = sumcheck.prove(instance); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 2d213345427..66e4210066e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -345,6 +345,14 @@ class AvmCircuitBuilder { polys.avm_mem_val[i] = rows[i].avm_mem_val; polys.avm_mem_w_in_tag[i] = rows[i].avm_mem_w_in_tag; polys.perm_main_alu[i] = rows[i].perm_main_alu; + + polys.lookup_byte_lengths_counts[i] = rows[i].lookup_byte_lengths_counts; + polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; + polys.incl_main_tag_err_counts[i] = rows[i].incl_main_tag_err_counts; + polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; + + // TODO: check that these are calculated at circuit building time - I believe they + // are rather added at proving time, and thus can be removed polys.perm_main_bin[i] = rows[i].perm_main_bin; polys.perm_main_mem_a[i] = rows[i].perm_main_mem_a; polys.perm_main_mem_b[i] = rows[i].perm_main_mem_b; @@ -356,10 +364,6 @@ class AvmCircuitBuilder { polys.lookup_byte_operations[i] = rows[i].lookup_byte_operations; polys.incl_main_tag_err[i] = rows[i].incl_main_tag_err; polys.incl_mem_tag_err[i] = rows[i].incl_mem_tag_err; - polys.lookup_byte_lengths_counts[i] = rows[i].lookup_byte_lengths_counts; - polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; - polys.incl_main_tag_err_counts[i] = rows[i].incl_main_tag_err_counts; - polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; } polys.avm_alu_u16_r0_shift = Polynomial(polys.avm_alu_u16_r0.shifted()); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp index a95109f38ca..b11475701be 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp @@ -31,7 +31,8 @@ AvmProver AvmComposer::create_prover(CircuitConstructor& circuit_constructor) compute_witness(circuit_constructor); compute_commitment_key(circuit_constructor.get_circuit_subgroup_size()); - AvmProver output_state(proving_key, commitment_key); + // TODO: check ptrs - align with other impls + AvmProver output_state(proving_key, proving_key->commitment_key); return output_state; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp index 1c072ebdf4e..2bde94ce2fb 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp @@ -60,9 +60,10 @@ class AvmComposer { void add_table_column_selector_poly_to_proving_key(bb::polynomial& small, const std::string& tag); + // TODO: probably need to move - feels like a hack void compute_commitment_key(size_t circuit_size) { - commitment_key = std::make_shared(circuit_size); + proving_key->commitment_key = std::make_shared(circuit_size); }; }; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 5814cb14c53..54529ea5174 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -17,6 +17,10 @@ #include "barretenberg/relations/generated/avm/avm_binary.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" #include "barretenberg/relations/generated/avm/avm_mem.hpp" +#include "barretenberg/relations/generated/avm/incl_main_tag_err.hpp" +#include "barretenberg/relations/generated/avm/incl_mem_tag_err.hpp" +#include "barretenberg/relations/generated/avm/lookup_byte_lengths.hpp" +#include "barretenberg/relations/generated/avm/lookup_byte_operations.hpp" #include "barretenberg/relations/generated/avm/perm_main_alu.hpp" #include "barretenberg/relations/generated/avm/perm_main_bin.hpp" #include "barretenberg/relations/generated/avm/perm_main_mem_a.hpp" @@ -60,7 +64,11 @@ class AvmFlavor { perm_main_mem_c_relation, perm_main_mem_ind_a_relation, perm_main_mem_ind_b_relation, - perm_main_mem_ind_c_relation>; + perm_main_mem_ind_c_relation, + incl_main_tag_err_relation, + incl_mem_tag_err_relation, + lookup_byte_lengths_relation, + lookup_byte_operations_relation>; using Relations = std::tuple, Avm_vm::avm_binary, @@ -73,7 +81,11 @@ class AvmFlavor { perm_main_mem_c_relation, perm_main_mem_ind_a_relation, perm_main_mem_ind_b_relation, - perm_main_mem_ind_c_relation>; + perm_main_mem_ind_c_relation, + incl_main_tag_err_relation, + incl_mem_tag_err_relation, + lookup_byte_lengths_relation, + lookup_byte_operations_relation>; static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); @@ -387,6 +399,152 @@ class AvmFlavor { incl_main_tag_err_counts, incl_mem_tag_err_counts }; }; + + // TEMP: only return relevant witness wires, we do not need lookup inverses etc + RefVector get_wit_wires() + { + return { + avm_alu_alu_sel, + avm_alu_cf, + avm_alu_clk, + avm_alu_ff_tag, + avm_alu_ia, + avm_alu_ib, + avm_alu_ic, + avm_alu_in_tag, + avm_alu_op_add, + avm_alu_op_div, + avm_alu_op_eq, + avm_alu_op_eq_diff_inv, + avm_alu_op_mul, + avm_alu_op_not, + avm_alu_op_sub, + avm_alu_u128_tag, + avm_alu_u16_r0, + avm_alu_u16_r1, + avm_alu_u16_r10, + avm_alu_u16_r11, + avm_alu_u16_r12, + avm_alu_u16_r13, + avm_alu_u16_r14, + avm_alu_u16_r2, + avm_alu_u16_r3, + avm_alu_u16_r4, + avm_alu_u16_r5, + avm_alu_u16_r6, + avm_alu_u16_r7, + avm_alu_u16_r8, + avm_alu_u16_r9, + avm_alu_u16_tag, + avm_alu_u32_tag, + avm_alu_u64_r0, + avm_alu_u64_tag, + avm_alu_u8_r0, + avm_alu_u8_r1, + avm_alu_u8_tag, + avm_binary_acc_ia, + avm_binary_acc_ib, + avm_binary_acc_ic, + avm_binary_bin_sel, + avm_binary_clk, + avm_binary_ia_bytes, + avm_binary_ib_bytes, + avm_binary_ic_bytes, + avm_binary_in_tag, + avm_binary_mem_tag_ctr, + avm_binary_mem_tag_ctr_inv, + avm_binary_op_id, + avm_binary_start, + avm_byte_lookup_bin_sel, + avm_byte_lookup_table_byte_lengths, + avm_byte_lookup_table_in_tags, + avm_byte_lookup_table_input_a, + avm_byte_lookup_table_input_b, + avm_byte_lookup_table_op_id, + avm_byte_lookup_table_output, + avm_main_alu_sel, + avm_main_bin_op_id, + avm_main_bin_sel, + avm_main_ia, + avm_main_ib, + avm_main_ic, + avm_main_ind_a, + avm_main_ind_b, + avm_main_ind_c, + avm_main_ind_op_a, + avm_main_ind_op_b, + avm_main_ind_op_c, + avm_main_internal_return_ptr, + avm_main_inv, + avm_main_last, + avm_main_mem_idx_a, + avm_main_mem_idx_b, + avm_main_mem_idx_c, + avm_main_mem_op_a, + avm_main_mem_op_b, + avm_main_mem_op_c, + avm_main_op_err, + avm_main_pc, + avm_main_r_in_tag, + avm_main_rwa, + avm_main_rwb, + avm_main_rwc, + avm_main_sel_halt, + avm_main_sel_internal_call, + avm_main_sel_internal_return, + avm_main_sel_jump, + avm_main_sel_mov, + avm_main_sel_op_add, + avm_main_sel_op_and, + avm_main_sel_op_div, + avm_main_sel_op_eq, + avm_main_sel_op_mul, + avm_main_sel_op_not, + avm_main_sel_op_or, + avm_main_sel_op_sub, + avm_main_sel_op_xor, + avm_main_sel_rng_16, + avm_main_sel_rng_8, + avm_main_tag_err, + avm_main_w_in_tag, + avm_mem_addr, + avm_mem_clk, + avm_mem_ind_op_a, + avm_mem_ind_op_b, + avm_mem_ind_op_c, + avm_mem_last, + avm_mem_lastAccess, + avm_mem_one_min_inv, + avm_mem_op_a, + avm_mem_op_b, + avm_mem_op_c, + avm_mem_r_in_tag, + avm_mem_rw, + avm_mem_sel_mov, + avm_mem_sub_clk, + avm_mem_tag, + avm_mem_tag_err, + avm_mem_val, + avm_mem_w_in_tag, + // perm_main_alu, + // perm_main_bin, + // perm_main_mem_a, + // perm_main_mem_b, + // perm_main_mem_c, + // perm_main_mem_ind_a, + // perm_main_mem_ind_b, + // perm_main_mem_ind_c, + // lookup_byte_lengths, + // lookup_byte_operations, + // incl_main_tag_err, + // incl_mem_tag_err, + // lookup_byte_lengths_counts, + // lookup_byte_operations_counts, + // incl_main_tag_err_counts, + // incl_mem_tag_err_counts + }; + }; + RefVector get_sorted_polynomials() { return {}; }; }; @@ -924,21 +1082,29 @@ class AvmFlavor { // perm_main_mem_ind_c_relation>; // One of these for each - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); // TODO: check if this has set the inverse for each of the polys @@ -946,7 +1112,30 @@ class AvmFlavor { } }; - using VerificationKey = VerificationKey_, VerifierCommitmentKey>; + // TODO: altered this to be a class + // using VerificationKey = VerificationKey_, VerifierCommitmentKey>; + class VerificationKey : public VerificationKey_, VerifierCommitmentKey> { + public: + VerificationKey() = default; + VerificationKey(const size_t circuit_size, const size_t num_public_inputs) + : VerificationKey_(circuit_size, num_public_inputs) + {} + + VerificationKey(ProvingKey& proving_key) + { + this->pcs_verification_key = std::make_shared(); + this->circuit_size = proving_key.circuit_size; + this->log_circuit_size = numeric::get_msb(this->circuit_size); + this->num_public_inputs = proving_key.num_public_inputs; + + // TODO(md): we shouldnt have this + this->pub_inputs_offset = proving_key.pub_inputs_offset; + + for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) { + commitment = proving_key.commitment_key->commit(polynomial); + } + } + }; using FoldedPolynomials = AllEntities>; @@ -1022,6 +1211,12 @@ class AvmFlavor { */ using ExtendedEdges = ProverUnivariates; + /** + * @brief A container for the witness commitments. + * + */ + using WitnessCommitments = WitnessEntities; + class CommitmentLabels : public AllEntities { private: using Base = AllEntities; @@ -1311,6 +1506,8 @@ class AvmFlavor { Commitment avm_mem_tag_err; Commitment avm_mem_val; Commitment avm_mem_w_in_tag; + + // Perm inverses Commitment perm_main_alu; Commitment perm_main_bin; Commitment perm_main_mem_a; @@ -1319,10 +1516,13 @@ class AvmFlavor { Commitment perm_main_mem_ind_a; Commitment perm_main_mem_ind_b; Commitment perm_main_mem_ind_c; + // Lookup inverses Commitment lookup_byte_lengths; Commitment lookup_byte_operations; Commitment incl_main_tag_err; Commitment incl_mem_tag_err; + + // Lookup counts Commitment lookup_byte_lengths_counts; Commitment lookup_byte_operations_counts; Commitment incl_main_tag_err_counts; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index 3968cf5b6b7..811e300f40e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -48,6 +48,7 @@ void AvmProver::execute_preamble_round() const auto circuit_size = static_cast(key->circuit_size); transcript->send_to_verifier("circuit_size", circuit_size); + info("Sent circuit size to verifier: ", circuit_size); } /** @@ -56,40 +57,344 @@ void AvmProver::execute_preamble_round() */ void AvmProver::execute_wire_commitments_round() { - auto wire_polys = key->get_wires(); - auto labels = commitment_labels.get_wires(); - for (size_t idx = 0; idx < wire_polys.size(); ++idx) { - transcript->send_to_verifier(labels[idx], commitment_key->commit(wire_polys[idx])); - } + // auto wire_polys = key->get_wit_wires(); + + // // TEMP: fine just using wires here and not wit wires as the indexes should still line up + // auto labels = commitment_labels.get_wires(); + // for (size_t idx = 0; idx < wire_polys.size(); ++idx) { + // info("Committing to wire ", labels[idx]); + // transcript->send_to_verifier(labels[idx], commitment_key->commit(wire_polys[idx])); + // } + + // TODO: while debugging Temporarily manually commit to each wire + // All witness commitments + // TODO: check these -> was done with a macro + auto labels = commitment_labels; + + witness_commitments.avm_alu_alu_sel = commitment_key->commit(key->avm_alu_alu_sel); + witness_commitments.avm_alu_cf = commitment_key->commit(key->avm_alu_cf); + witness_commitments.avm_alu_clk = commitment_key->commit(key->avm_alu_clk); + witness_commitments.avm_alu_ff_tag = commitment_key->commit(key->avm_alu_ff_tag); + witness_commitments.avm_alu_ia = commitment_key->commit(key->avm_alu_ia); + witness_commitments.avm_alu_ib = commitment_key->commit(key->avm_alu_ib); + witness_commitments.avm_alu_ic = commitment_key->commit(key->avm_alu_ic); + witness_commitments.avm_alu_in_tag = commitment_key->commit(key->avm_alu_in_tag); + witness_commitments.avm_alu_op_add = commitment_key->commit(key->avm_alu_op_add); + witness_commitments.avm_alu_op_div = commitment_key->commit(key->avm_alu_op_div); + witness_commitments.avm_alu_op_eq = commitment_key->commit(key->avm_alu_op_eq); + witness_commitments.avm_alu_op_eq_diff_inv = commitment_key->commit(key->avm_alu_op_eq_diff_inv); + witness_commitments.avm_alu_op_mul = commitment_key->commit(key->avm_alu_op_mul); + witness_commitments.avm_alu_op_not = commitment_key->commit(key->avm_alu_op_not); + witness_commitments.avm_alu_op_sub = commitment_key->commit(key->avm_alu_op_sub); + witness_commitments.avm_alu_u128_tag = commitment_key->commit(key->avm_alu_u128_tag); + witness_commitments.avm_alu_u16_r0 = commitment_key->commit(key->avm_alu_u16_r0); + witness_commitments.avm_alu_u16_r1 = commitment_key->commit(key->avm_alu_u16_r1); + witness_commitments.avm_alu_u16_r10 = commitment_key->commit(key->avm_alu_u16_r10); + witness_commitments.avm_alu_u16_r11 = commitment_key->commit(key->avm_alu_u16_r11); + witness_commitments.avm_alu_u16_r12 = commitment_key->commit(key->avm_alu_u16_r12); + witness_commitments.avm_alu_u16_r13 = commitment_key->commit(key->avm_alu_u16_r13); + witness_commitments.avm_alu_u16_r14 = commitment_key->commit(key->avm_alu_u16_r14); + witness_commitments.avm_alu_u16_r2 = commitment_key->commit(key->avm_alu_u16_r2); + witness_commitments.avm_alu_u16_r3 = commitment_key->commit(key->avm_alu_u16_r3); + witness_commitments.avm_alu_u16_r4 = commitment_key->commit(key->avm_alu_u16_r4); + witness_commitments.avm_alu_u16_r5 = commitment_key->commit(key->avm_alu_u16_r5); + witness_commitments.avm_alu_u16_r6 = commitment_key->commit(key->avm_alu_u16_r6); + witness_commitments.avm_alu_u16_r7 = commitment_key->commit(key->avm_alu_u16_r7); + witness_commitments.avm_alu_u16_r8 = commitment_key->commit(key->avm_alu_u16_r8); + witness_commitments.avm_alu_u16_r9 = commitment_key->commit(key->avm_alu_u16_r9); + witness_commitments.avm_alu_u16_tag = commitment_key->commit(key->avm_alu_u16_tag); + witness_commitments.avm_alu_u32_tag = commitment_key->commit(key->avm_alu_u32_tag); + witness_commitments.avm_alu_u64_r0 = commitment_key->commit(key->avm_alu_u64_r0); + witness_commitments.avm_alu_u64_tag = commitment_key->commit(key->avm_alu_u64_tag); + witness_commitments.avm_alu_u8_r0 = commitment_key->commit(key->avm_alu_u8_r0); + witness_commitments.avm_alu_u8_r1 = commitment_key->commit(key->avm_alu_u8_r1); + witness_commitments.avm_alu_u8_tag = commitment_key->commit(key->avm_alu_u8_tag); + witness_commitments.avm_binary_acc_ia = commitment_key->commit(key->avm_binary_acc_ia); + witness_commitments.avm_binary_acc_ib = commitment_key->commit(key->avm_binary_acc_ib); + witness_commitments.avm_binary_acc_ic = commitment_key->commit(key->avm_binary_acc_ic); + witness_commitments.avm_binary_bin_sel = commitment_key->commit(key->avm_binary_bin_sel); + witness_commitments.avm_binary_clk = commitment_key->commit(key->avm_binary_clk); + witness_commitments.avm_binary_ia_bytes = commitment_key->commit(key->avm_binary_ia_bytes); + witness_commitments.avm_binary_ib_bytes = commitment_key->commit(key->avm_binary_ib_bytes); + witness_commitments.avm_binary_ic_bytes = commitment_key->commit(key->avm_binary_ic_bytes); + witness_commitments.avm_binary_in_tag = commitment_key->commit(key->avm_binary_in_tag); + witness_commitments.avm_binary_mem_tag_ctr = commitment_key->commit(key->avm_binary_mem_tag_ctr); + witness_commitments.avm_binary_mem_tag_ctr_inv = commitment_key->commit(key->avm_binary_mem_tag_ctr_inv); + witness_commitments.avm_binary_op_id = commitment_key->commit(key->avm_binary_op_id); + witness_commitments.avm_binary_start = commitment_key->commit(key->avm_binary_start); + witness_commitments.avm_byte_lookup_bin_sel = commitment_key->commit(key->avm_byte_lookup_bin_sel); + witness_commitments.avm_byte_lookup_table_byte_lengths = + commitment_key->commit(key->avm_byte_lookup_table_byte_lengths); + witness_commitments.avm_byte_lookup_table_in_tags = commitment_key->commit(key->avm_byte_lookup_table_in_tags); + witness_commitments.avm_byte_lookup_table_input_a = commitment_key->commit(key->avm_byte_lookup_table_input_a); + witness_commitments.avm_byte_lookup_table_input_b = commitment_key->commit(key->avm_byte_lookup_table_input_b); + witness_commitments.avm_byte_lookup_table_op_id = commitment_key->commit(key->avm_byte_lookup_table_op_id); + witness_commitments.avm_byte_lookup_table_output = commitment_key->commit(key->avm_byte_lookup_table_output); + witness_commitments.avm_main_alu_sel = commitment_key->commit(key->avm_main_alu_sel); + witness_commitments.avm_main_bin_op_id = commitment_key->commit(key->avm_main_bin_op_id); + witness_commitments.avm_main_bin_sel = commitment_key->commit(key->avm_main_bin_sel); + witness_commitments.avm_main_ia = commitment_key->commit(key->avm_main_ia); + witness_commitments.avm_main_ib = commitment_key->commit(key->avm_main_ib); + witness_commitments.avm_main_ic = commitment_key->commit(key->avm_main_ic); + witness_commitments.avm_main_ind_a = commitment_key->commit(key->avm_main_ind_a); + witness_commitments.avm_main_ind_b = commitment_key->commit(key->avm_main_ind_b); + witness_commitments.avm_main_ind_c = commitment_key->commit(key->avm_main_ind_c); + witness_commitments.avm_main_ind_op_a = commitment_key->commit(key->avm_main_ind_op_a); + witness_commitments.avm_main_ind_op_b = commitment_key->commit(key->avm_main_ind_op_b); + witness_commitments.avm_main_ind_op_c = commitment_key->commit(key->avm_main_ind_op_c); + witness_commitments.avm_main_internal_return_ptr = commitment_key->commit(key->avm_main_internal_return_ptr); + witness_commitments.avm_main_inv = commitment_key->commit(key->avm_main_inv); + witness_commitments.avm_main_last = commitment_key->commit(key->avm_main_last); + witness_commitments.avm_main_mem_idx_a = commitment_key->commit(key->avm_main_mem_idx_a); + witness_commitments.avm_main_mem_idx_b = commitment_key->commit(key->avm_main_mem_idx_b); + witness_commitments.avm_main_mem_idx_c = commitment_key->commit(key->avm_main_mem_idx_c); + witness_commitments.avm_main_mem_op_a = commitment_key->commit(key->avm_main_mem_op_a); + witness_commitments.avm_main_mem_op_b = commitment_key->commit(key->avm_main_mem_op_b); + witness_commitments.avm_main_mem_op_c = commitment_key->commit(key->avm_main_mem_op_c); + witness_commitments.avm_main_op_err = commitment_key->commit(key->avm_main_op_err); + witness_commitments.avm_main_pc = commitment_key->commit(key->avm_main_pc); + witness_commitments.avm_main_r_in_tag = commitment_key->commit(key->avm_main_r_in_tag); + witness_commitments.avm_main_rwa = commitment_key->commit(key->avm_main_rwa); + witness_commitments.avm_main_rwb = commitment_key->commit(key->avm_main_rwb); + witness_commitments.avm_main_rwc = commitment_key->commit(key->avm_main_rwc); + witness_commitments.avm_main_sel_halt = commitment_key->commit(key->avm_main_sel_halt); + witness_commitments.avm_main_sel_internal_call = commitment_key->commit(key->avm_main_sel_internal_call); + witness_commitments.avm_main_sel_internal_return = commitment_key->commit(key->avm_main_sel_internal_return); + witness_commitments.avm_main_sel_jump = commitment_key->commit(key->avm_main_sel_jump); + witness_commitments.avm_main_sel_mov = commitment_key->commit(key->avm_main_sel_mov); + witness_commitments.avm_main_sel_op_add = commitment_key->commit(key->avm_main_sel_op_add); + witness_commitments.avm_main_sel_op_and = commitment_key->commit(key->avm_main_sel_op_and); + witness_commitments.avm_main_sel_op_div = commitment_key->commit(key->avm_main_sel_op_div); + witness_commitments.avm_main_sel_op_eq = commitment_key->commit(key->avm_main_sel_op_eq); + witness_commitments.avm_main_sel_op_mul = commitment_key->commit(key->avm_main_sel_op_mul); + witness_commitments.avm_main_sel_op_not = commitment_key->commit(key->avm_main_sel_op_not); + witness_commitments.avm_main_sel_op_or = commitment_key->commit(key->avm_main_sel_op_or); + witness_commitments.avm_main_sel_op_sub = commitment_key->commit(key->avm_main_sel_op_sub); + witness_commitments.avm_main_sel_op_xor = commitment_key->commit(key->avm_main_sel_op_xor); + witness_commitments.avm_main_sel_rng_16 = commitment_key->commit(key->avm_main_sel_rng_16); + witness_commitments.avm_main_sel_rng_8 = commitment_key->commit(key->avm_main_sel_rng_8); + witness_commitments.avm_main_tag_err = commitment_key->commit(key->avm_main_tag_err); + witness_commitments.avm_main_w_in_tag = commitment_key->commit(key->avm_main_w_in_tag); + witness_commitments.avm_mem_addr = commitment_key->commit(key->avm_mem_addr); + witness_commitments.avm_mem_clk = commitment_key->commit(key->avm_mem_clk); + witness_commitments.avm_mem_ind_op_a = commitment_key->commit(key->avm_mem_ind_op_a); + witness_commitments.avm_mem_ind_op_b = commitment_key->commit(key->avm_mem_ind_op_b); + witness_commitments.avm_mem_ind_op_c = commitment_key->commit(key->avm_mem_ind_op_c); + witness_commitments.avm_mem_last = commitment_key->commit(key->avm_mem_last); + witness_commitments.avm_mem_lastAccess = commitment_key->commit(key->avm_mem_lastAccess); + witness_commitments.avm_mem_one_min_inv = commitment_key->commit(key->avm_mem_one_min_inv); + witness_commitments.avm_mem_op_a = commitment_key->commit(key->avm_mem_op_a); + witness_commitments.avm_mem_op_b = commitment_key->commit(key->avm_mem_op_b); + witness_commitments.avm_mem_op_c = commitment_key->commit(key->avm_mem_op_c); + witness_commitments.avm_mem_r_in_tag = commitment_key->commit(key->avm_mem_r_in_tag); + witness_commitments.avm_mem_rw = commitment_key->commit(key->avm_mem_rw); + witness_commitments.avm_mem_sel_mov = commitment_key->commit(key->avm_mem_sel_mov); + witness_commitments.avm_mem_sub_clk = commitment_key->commit(key->avm_mem_sub_clk); + witness_commitments.avm_mem_tag = commitment_key->commit(key->avm_mem_tag); + witness_commitments.avm_mem_tag_err = commitment_key->commit(key->avm_mem_tag_err); + witness_commitments.avm_mem_val = commitment_key->commit(key->avm_mem_val); + witness_commitments.avm_mem_w_in_tag = commitment_key->commit(key->avm_mem_w_in_tag); + + // Lookup counts + witness_commitments.lookup_byte_lengths_counts = commitment_key->commit(key->lookup_byte_lengths_counts); + witness_commitments.lookup_byte_operations_counts = commitment_key->commit(key->lookup_byte_operations_counts); + witness_commitments.incl_main_tag_err_counts = commitment_key->commit(key->incl_main_tag_err_counts); + witness_commitments.incl_mem_tag_err_counts = commitment_key->commit(key->incl_mem_tag_err_counts); + + // print some of the commitments to check they have values + + // Send all witness commitments to the verifier + transcript->send_to_verifier(labels.avm_alu_alu_sel, witness_commitments.avm_alu_alu_sel); + transcript->send_to_verifier(labels.avm_alu_cf, witness_commitments.avm_alu_cf); + transcript->send_to_verifier(labels.avm_alu_clk, witness_commitments.avm_alu_clk); + transcript->send_to_verifier(labels.avm_alu_ff_tag, witness_commitments.avm_alu_ff_tag); + transcript->send_to_verifier(labels.avm_alu_ia, witness_commitments.avm_alu_ia); + transcript->send_to_verifier(labels.avm_alu_ib, witness_commitments.avm_alu_ib); + transcript->send_to_verifier(labels.avm_alu_ic, witness_commitments.avm_alu_ic); + transcript->send_to_verifier(labels.avm_alu_in_tag, witness_commitments.avm_alu_in_tag); + transcript->send_to_verifier(labels.avm_alu_op_add, witness_commitments.avm_alu_op_add); + transcript->send_to_verifier(labels.avm_alu_op_div, witness_commitments.avm_alu_op_div); + transcript->send_to_verifier(labels.avm_alu_op_eq, witness_commitments.avm_alu_op_eq); + transcript->send_to_verifier(labels.avm_alu_op_eq_diff_inv, witness_commitments.avm_alu_op_eq_diff_inv); + transcript->send_to_verifier(labels.avm_alu_op_mul, witness_commitments.avm_alu_op_mul); + transcript->send_to_verifier(labels.avm_alu_op_not, witness_commitments.avm_alu_op_not); + transcript->send_to_verifier(labels.avm_alu_op_sub, witness_commitments.avm_alu_op_sub); + transcript->send_to_verifier(labels.avm_alu_u128_tag, witness_commitments.avm_alu_u128_tag); + transcript->send_to_verifier(labels.avm_alu_u16_r0, witness_commitments.avm_alu_u16_r0); + transcript->send_to_verifier(labels.avm_alu_u16_r1, witness_commitments.avm_alu_u16_r1); + transcript->send_to_verifier(labels.avm_alu_u16_r10, witness_commitments.avm_alu_u16_r10); + transcript->send_to_verifier(labels.avm_alu_u16_r11, witness_commitments.avm_alu_u16_r11); + transcript->send_to_verifier(labels.avm_alu_u16_r12, witness_commitments.avm_alu_u16_r12); + transcript->send_to_verifier(labels.avm_alu_u16_r13, witness_commitments.avm_alu_u16_r13); + transcript->send_to_verifier(labels.avm_alu_u16_r14, witness_commitments.avm_alu_u16_r14); + transcript->send_to_verifier(labels.avm_alu_u16_r2, witness_commitments.avm_alu_u16_r2); + transcript->send_to_verifier(labels.avm_alu_u16_r3, witness_commitments.avm_alu_u16_r3); + transcript->send_to_verifier(labels.avm_alu_u16_r4, witness_commitments.avm_alu_u16_r4); + transcript->send_to_verifier(labels.avm_alu_u16_r5, witness_commitments.avm_alu_u16_r5); + transcript->send_to_verifier(labels.avm_alu_u16_r6, witness_commitments.avm_alu_u16_r6); + transcript->send_to_verifier(labels.avm_alu_u16_r7, witness_commitments.avm_alu_u16_r7); + transcript->send_to_verifier(labels.avm_alu_u16_r8, witness_commitments.avm_alu_u16_r8); + transcript->send_to_verifier(labels.avm_alu_u16_r9, witness_commitments.avm_alu_u16_r9); + transcript->send_to_verifier(labels.avm_alu_u16_tag, witness_commitments.avm_alu_u16_tag); + transcript->send_to_verifier(labels.avm_alu_u32_tag, witness_commitments.avm_alu_u32_tag); + transcript->send_to_verifier(labels.avm_alu_u64_r0, witness_commitments.avm_alu_u64_r0); + transcript->send_to_verifier(labels.avm_alu_u64_tag, witness_commitments.avm_alu_u64_tag); + transcript->send_to_verifier(labels.avm_alu_u8_r0, witness_commitments.avm_alu_u8_r0); + transcript->send_to_verifier(labels.avm_alu_u8_r1, witness_commitments.avm_alu_u8_r1); + transcript->send_to_verifier(labels.avm_alu_u8_tag, witness_commitments.avm_alu_u8_tag); + transcript->send_to_verifier(labels.avm_binary_acc_ia, witness_commitments.avm_binary_acc_ia); + transcript->send_to_verifier(labels.avm_binary_acc_ib, witness_commitments.avm_binary_acc_ib); + transcript->send_to_verifier(labels.avm_binary_acc_ic, witness_commitments.avm_binary_acc_ic); + transcript->send_to_verifier(labels.avm_binary_bin_sel, witness_commitments.avm_binary_bin_sel); + transcript->send_to_verifier(labels.avm_binary_clk, witness_commitments.avm_binary_clk); + transcript->send_to_verifier(labels.avm_binary_ia_bytes, witness_commitments.avm_binary_ia_bytes); + transcript->send_to_verifier(labels.avm_binary_ib_bytes, witness_commitments.avm_binary_ib_bytes); + transcript->send_to_verifier(labels.avm_binary_ic_bytes, witness_commitments.avm_binary_ic_bytes); + transcript->send_to_verifier(labels.avm_binary_in_tag, witness_commitments.avm_binary_in_tag); + transcript->send_to_verifier(labels.avm_binary_mem_tag_ctr, witness_commitments.avm_binary_mem_tag_ctr); + transcript->send_to_verifier(labels.avm_binary_mem_tag_ctr_inv, witness_commitments.avm_binary_mem_tag_ctr_inv); + transcript->send_to_verifier(labels.avm_binary_op_id, witness_commitments.avm_binary_op_id); + transcript->send_to_verifier(labels.avm_binary_start, witness_commitments.avm_binary_start); + transcript->send_to_verifier(labels.avm_byte_lookup_bin_sel, witness_commitments.avm_byte_lookup_bin_sel); + transcript->send_to_verifier(labels.avm_byte_lookup_table_byte_lengths, + witness_commitments.avm_byte_lookup_table_byte_lengths); + transcript->send_to_verifier(labels.avm_byte_lookup_table_in_tags, + witness_commitments.avm_byte_lookup_table_in_tags); + transcript->send_to_verifier(labels.avm_byte_lookup_table_input_a, + witness_commitments.avm_byte_lookup_table_input_a); + transcript->send_to_verifier(labels.avm_byte_lookup_table_input_b, + witness_commitments.avm_byte_lookup_table_input_b); + transcript->send_to_verifier(labels.avm_byte_lookup_table_op_id, witness_commitments.avm_byte_lookup_table_op_id); + transcript->send_to_verifier(labels.avm_byte_lookup_table_output, witness_commitments.avm_byte_lookup_table_output); + transcript->send_to_verifier(labels.avm_main_alu_sel, witness_commitments.avm_main_alu_sel); + transcript->send_to_verifier(labels.avm_main_bin_op_id, witness_commitments.avm_main_bin_op_id); + transcript->send_to_verifier(labels.avm_main_bin_sel, witness_commitments.avm_main_bin_sel); + transcript->send_to_verifier(labels.avm_main_ia, witness_commitments.avm_main_ia); + transcript->send_to_verifier(labels.avm_main_ib, witness_commitments.avm_main_ib); + transcript->send_to_verifier(labels.avm_main_ic, witness_commitments.avm_main_ic); + transcript->send_to_verifier(labels.avm_main_ind_a, witness_commitments.avm_main_ind_a); + transcript->send_to_verifier(labels.avm_main_ind_b, witness_commitments.avm_main_ind_b); + transcript->send_to_verifier(labels.avm_main_ind_c, witness_commitments.avm_main_ind_c); + transcript->send_to_verifier(labels.avm_main_ind_op_a, witness_commitments.avm_main_ind_op_a); + transcript->send_to_verifier(labels.avm_main_ind_op_b, witness_commitments.avm_main_ind_op_b); + transcript->send_to_verifier(labels.avm_main_ind_op_c, witness_commitments.avm_main_ind_op_c); + transcript->send_to_verifier(labels.avm_main_internal_return_ptr, witness_commitments.avm_main_internal_return_ptr); + transcript->send_to_verifier(labels.avm_main_inv, witness_commitments.avm_main_inv); + transcript->send_to_verifier(labels.avm_main_last, witness_commitments.avm_main_last); + transcript->send_to_verifier(labels.avm_main_mem_idx_a, witness_commitments.avm_main_mem_idx_a); + transcript->send_to_verifier(labels.avm_main_mem_idx_b, witness_commitments.avm_main_mem_idx_b); + transcript->send_to_verifier(labels.avm_main_mem_idx_c, witness_commitments.avm_main_mem_idx_c); + transcript->send_to_verifier(labels.avm_main_mem_op_a, witness_commitments.avm_main_mem_op_a); + transcript->send_to_verifier(labels.avm_main_mem_op_b, witness_commitments.avm_main_mem_op_b); + transcript->send_to_verifier(labels.avm_main_mem_op_c, witness_commitments.avm_main_mem_op_c); + transcript->send_to_verifier(labels.avm_main_op_err, witness_commitments.avm_main_op_err); + transcript->send_to_verifier(labels.avm_main_pc, witness_commitments.avm_main_pc); + transcript->send_to_verifier(labels.avm_main_r_in_tag, witness_commitments.avm_main_r_in_tag); + transcript->send_to_verifier(labels.avm_main_rwa, witness_commitments.avm_main_rwa); + transcript->send_to_verifier(labels.avm_main_rwb, witness_commitments.avm_main_rwb); + transcript->send_to_verifier(labels.avm_main_rwc, witness_commitments.avm_main_rwc); + transcript->send_to_verifier(labels.avm_main_sel_halt, witness_commitments.avm_main_sel_halt); + transcript->send_to_verifier(labels.avm_main_sel_internal_call, witness_commitments.avm_main_sel_internal_call); + transcript->send_to_verifier(labels.avm_main_sel_internal_return, witness_commitments.avm_main_sel_internal_return); + transcript->send_to_verifier(labels.avm_main_sel_jump, witness_commitments.avm_main_sel_jump); + transcript->send_to_verifier(labels.avm_main_sel_mov, witness_commitments.avm_main_sel_mov); + transcript->send_to_verifier(labels.avm_main_sel_op_add, witness_commitments.avm_main_sel_op_add); + transcript->send_to_verifier(labels.avm_main_sel_op_and, witness_commitments.avm_main_sel_op_and); + transcript->send_to_verifier(labels.avm_main_sel_op_div, witness_commitments.avm_main_sel_op_div); + transcript->send_to_verifier(labels.avm_main_sel_op_eq, witness_commitments.avm_main_sel_op_eq); + transcript->send_to_verifier(labels.avm_main_sel_op_mul, witness_commitments.avm_main_sel_op_mul); + transcript->send_to_verifier(labels.avm_main_sel_op_not, witness_commitments.avm_main_sel_op_not); + transcript->send_to_verifier(labels.avm_main_sel_op_or, witness_commitments.avm_main_sel_op_or); + transcript->send_to_verifier(labels.avm_main_sel_op_sub, witness_commitments.avm_main_sel_op_sub); + transcript->send_to_verifier(labels.avm_main_sel_op_xor, witness_commitments.avm_main_sel_op_xor); + transcript->send_to_verifier(labels.avm_main_sel_rng_16, witness_commitments.avm_main_sel_rng_16); + transcript->send_to_verifier(labels.avm_main_sel_rng_8, witness_commitments.avm_main_sel_rng_8); + transcript->send_to_verifier(labels.avm_main_tag_err, witness_commitments.avm_main_tag_err); + transcript->send_to_verifier(labels.avm_main_w_in_tag, witness_commitments.avm_main_w_in_tag); + transcript->send_to_verifier(labels.avm_mem_addr, witness_commitments.avm_mem_addr); + transcript->send_to_verifier(labels.avm_mem_clk, witness_commitments.avm_mem_clk); + transcript->send_to_verifier(labels.avm_mem_ind_op_a, witness_commitments.avm_mem_ind_op_a); + transcript->send_to_verifier(labels.avm_mem_ind_op_b, witness_commitments.avm_mem_ind_op_b); + transcript->send_to_verifier(labels.avm_mem_ind_op_c, witness_commitments.avm_mem_ind_op_c); + transcript->send_to_verifier(labels.avm_mem_last, witness_commitments.avm_mem_last); + transcript->send_to_verifier(labels.avm_mem_lastAccess, witness_commitments.avm_mem_lastAccess); + transcript->send_to_verifier(labels.avm_mem_one_min_inv, witness_commitments.avm_mem_one_min_inv); + transcript->send_to_verifier(labels.avm_mem_op_a, witness_commitments.avm_mem_op_a); + transcript->send_to_verifier(labels.avm_mem_op_b, witness_commitments.avm_mem_op_b); + transcript->send_to_verifier(labels.avm_mem_op_c, witness_commitments.avm_mem_op_c); + transcript->send_to_verifier(labels.avm_mem_r_in_tag, witness_commitments.avm_mem_r_in_tag); + transcript->send_to_verifier(labels.avm_mem_rw, witness_commitments.avm_mem_rw); + transcript->send_to_verifier(labels.avm_mem_sel_mov, witness_commitments.avm_mem_sel_mov); + transcript->send_to_verifier(labels.avm_mem_sub_clk, witness_commitments.avm_mem_sub_clk); + transcript->send_to_verifier(labels.avm_mem_tag, witness_commitments.avm_mem_tag); + transcript->send_to_verifier(labels.avm_mem_tag_err, witness_commitments.avm_mem_tag_err); + transcript->send_to_verifier(labels.avm_mem_val, witness_commitments.avm_mem_val); + transcript->send_to_verifier(labels.avm_mem_w_in_tag, witness_commitments.avm_mem_w_in_tag); + + // Lookup counts + transcript->send_to_verifier(labels.lookup_byte_lengths_counts, witness_commitments.lookup_byte_lengths_counts); + transcript->send_to_verifier(labels.lookup_byte_operations_counts, + witness_commitments.lookup_byte_operations_counts); + transcript->send_to_verifier(labels.incl_main_tag_err_counts, witness_commitments.incl_main_tag_err_counts); + transcript->send_to_verifier(labels.incl_mem_tag_err_counts, witness_commitments.incl_mem_tag_err_counts); + + info("sent all witness contributions to the prover manually "); } void AvmProver::execute_log_derivative_inverse_round() { auto [beta, gamma] = transcript->template get_challenges("beta", "gamma"); + + info("prover beta ", beta); + info("prover gamma ", gamma); + + auto beta_sqr = beta * beta; + auto beta_cube = beta_sqr * beta; relation_parameters.beta = beta; relation_parameters.gamma = gamma; + relation_parameters.beta_sqr = beta_sqr; + relation_parameters.beta_cube = beta_cube; // TODO: Add an implementation of this to the flavor // We will need to compute -> the inverse for each column and add it to the proving key // -> I think we should be able to use each of the bespoke lookup relations for this??? - // -> - // snippet is below - /** - void compute_logderivative_inverse(const RelationParameters& relation_parameters) - { - auto prover_polynomials = ProverPolynomials(*this); - // Compute permutation and lookup grand product polynomials - bb::compute_logderivative_inverse( - prover_polynomials, relation_parameters, this->circuit_size); - this->lookup_inverses = prover_polynomials.lookup_inverses; - } - */ key->compute_logderivative_inverses(relation_parameters); - // Add commitments for each below - // witness_commitments.lookup_inverses = commitment_key->commit(proving_key.lookup_inverses); - // transcript->send_to_verifier(domain_separator + commitment_labels.lookup_inverses, - // witness_commitments.lookup_inverses); + + // Send each computed inverse to the verifier + // TODO(md): why is it computed within the flavor and not here? seems like it could be? + + // Permutations + witness_commitments.perm_main_alu = commitment_key->commit(key->perm_main_alu); + witness_commitments.perm_main_bin = commitment_key->commit(key->perm_main_bin); + witness_commitments.perm_main_mem_a = commitment_key->commit(key->perm_main_mem_a); + witness_commitments.perm_main_mem_b = commitment_key->commit(key->perm_main_mem_b); + witness_commitments.perm_main_mem_c = commitment_key->commit(key->perm_main_mem_c); + witness_commitments.perm_main_mem_ind_a = commitment_key->commit(key->perm_main_mem_ind_a); + witness_commitments.perm_main_mem_ind_b = commitment_key->commit(key->perm_main_mem_ind_b); + witness_commitments.perm_main_mem_ind_c = commitment_key->commit(key->perm_main_mem_ind_c); + // Lookups + witness_commitments.incl_main_tag_err = commitment_key->commit(key->incl_main_tag_err); + witness_commitments.incl_mem_tag_err = commitment_key->commit(key->incl_mem_tag_err); + witness_commitments.lookup_byte_lengths = commitment_key->commit(key->lookup_byte_lengths); + witness_commitments.lookup_byte_operations = commitment_key->commit(key->lookup_byte_operations); + + // Perms + transcript->send_to_verifier(commitment_labels.perm_main_alu, witness_commitments.perm_main_alu); + transcript->send_to_verifier(commitment_labels.perm_main_bin, witness_commitments.perm_main_bin); + transcript->send_to_verifier(commitment_labels.perm_main_mem_a, witness_commitments.perm_main_mem_a); + transcript->send_to_verifier(commitment_labels.perm_main_mem_b, witness_commitments.perm_main_mem_b); + transcript->send_to_verifier(commitment_labels.perm_main_mem_c, witness_commitments.perm_main_mem_b); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_a, witness_commitments.perm_main_mem_ind_a); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_b, witness_commitments.perm_main_mem_ind_b); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_c, witness_commitments.perm_main_mem_ind_c); + // Lookups + transcript->send_to_verifier(commitment_labels.incl_main_tag_err, witness_commitments.incl_main_tag_err); + transcript->send_to_verifier(commitment_labels.incl_mem_tag_err, witness_commitments.incl_mem_tag_err); + transcript->send_to_verifier(commitment_labels.lookup_byte_lengths, witness_commitments.lookup_byte_lengths); + transcript->send_to_verifier(commitment_labels.lookup_byte_operations, witness_commitments.lookup_byte_operations); + + info("lookup byte operations ", witness_commitments.lookup_byte_operations); } /** @@ -98,17 +403,22 @@ void AvmProver::execute_log_derivative_inverse_round() */ void AvmProver::execute_relation_check_rounds() { + // TODO: check prover polynomials are set here + using Sumcheck = SumcheckProver; auto sumcheck = Sumcheck(key->circuit_size, transcript); FF alpha = transcript->template get_challenge("Sumcheck:alpha"); + info("get msb ", numeric::get_msb(key->circuit_size)); std::vector gate_challenges(numeric::get_msb(key->circuit_size)); for (size_t idx = 0; idx < gate_challenges.size(); idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); + info("gate chall", gate_challenges[idx]); } sumcheck_output = sumcheck.prove(prover_polynomials, relation_parameters, alpha, gate_challenges); + // info("Sumcheck output ", sumcheck_output); } /** @@ -142,11 +452,8 @@ HonkProof& AvmProver::construct_proof() execute_wire_commitments_round(); // Compute sorted list accumulator and commitment - execute_log_derivative_commitments_round(); - // Fiat-Shamir: bbeta & gamma - // Compute grand product(s) and commitments. - execute_grand_product_computation_round(); + execute_log_derivative_inverse_round(); // Fiat-Shamir: alpha // Run sumcheck subprotocol. diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp index 324373fa7cc..47e2603a9ca 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp @@ -47,6 +47,7 @@ class AvmProver { ProverPolynomials prover_polynomials; CommitmentLabels commitment_labels; + typename Flavor::WitnessCommitments witness_commitments; Polynomial quotient_W; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 89676bd4a64..6e21e0e6ca3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -47,8 +47,10 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) const auto circuit_size = transcript->template receive_from_prover("circuit_size"); if (circuit_size != key->circuit_size) { + info("circuit_size does not line up: {} != {}", circuit_size, key->circuit_size); return false; } + info("circuit_size has lined up: {}", circuit_size); // Get commitments to VM wires commitments.avm_alu_alu_sel = @@ -246,6 +248,33 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) commitments.avm_mem_val = transcript->template receive_from_prover(commitment_labels.avm_mem_val); commitments.avm_mem_w_in_tag = transcript->template receive_from_prover(commitment_labels.avm_mem_w_in_tag); + + // Lookup counts + commitments.lookup_byte_lengths_counts = + transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths_counts); + commitments.lookup_byte_operations_counts = + transcript->template receive_from_prover(commitment_labels.lookup_byte_operations_counts); + commitments.incl_main_tag_err_counts = + transcript->template receive_from_prover(commitment_labels.incl_main_tag_err_counts); + commitments.incl_mem_tag_err_counts = + transcript->template receive_from_prover(commitment_labels.incl_mem_tag_err_counts); + + // TODO: Check that these all have values + + // Calculate the alpha and beta challenges - log derivative inverse round + auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); + + info("verifier beta = ", beta); + info("verifier gamma = ", gamm); + + auto beta_sqr = beta * beta; + auto beta_cube = beta_sqr * beta; + relation_parameters.beta = beta; + relation_parameters.gamma = gamm; + relation_parameters.beta_sqr = beta_sqr; + relation_parameters.beta_cube = beta_cube; + + // Permutations commitments.perm_main_alu = transcript->template receive_from_prover(commitment_labels.perm_main_alu); commitments.perm_main_bin = transcript->template receive_from_prover(commitment_labels.perm_main_bin); commitments.perm_main_mem_a = @@ -260,6 +289,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_b); commitments.perm_main_mem_ind_c = transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_c); + + // Lookups commitments.lookup_byte_lengths = transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths); commitments.lookup_byte_operations = @@ -268,14 +299,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.incl_main_tag_err); commitments.incl_mem_tag_err = transcript->template receive_from_prover(commitment_labels.incl_mem_tag_err); - commitments.lookup_byte_lengths_counts = - transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths_counts); - commitments.lookup_byte_operations_counts = - transcript->template receive_from_prover(commitment_labels.lookup_byte_operations_counts); - commitments.incl_main_tag_err_counts = - transcript->template receive_from_prover(commitment_labels.incl_main_tag_err_counts); - commitments.incl_mem_tag_err_counts = - transcript->template receive_from_prover(commitment_labels.incl_mem_tag_err_counts); // Execute Sumcheck Verifier const size_t log_circuit_size = numeric::get_msb(circuit_size); @@ -286,6 +309,7 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) auto gate_challenges = std::vector(log_circuit_size); for (size_t idx = 0; idx < log_circuit_size; idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); + info("verifier gate_challenges[", idx, "] = ", gate_challenges[idx]); } auto [multivariate_challenge, claimed_evaluations, sumcheck_verified] = @@ -293,6 +317,7 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) // If Sumcheck did not verify, return false if (sumcheck_verified.has_value() && !sumcheck_verified.value()) { + info("Sumcheck did not verify"); return false; } diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 3e5efaa4efa..978ac87f12e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -1,4 +1,25 @@ #include "avm_common.test.hpp" +#include "barretenberg/vm/generated/avm_flavor.hpp" +#include +#include + +// TODO: remove this +std::string bytes_to_hex_string(const std::vector& input) +{ + static const char characters[] = "0123456789ABCDEF"; + + // Zeroes out the buffer unnecessarily, can't be avoided for std::string. + std::string ret(input.size() * 2, 0); + + // Hack... Against the rules but avoids copying the whole buffer. + auto buf = const_cast(ret.data()); + + for (const auto& oneInputByte : input) { + *buf++ = characters[oneInputByte >> 4]; + *buf++ = characters[oneInputByte & 0x0F]; + } + return ret; +} namespace tests_avm { /** @@ -13,14 +34,18 @@ void validate_trace_proof(std::vector&& trace) EXPECT_TRUE(circuit_builder.check_circuit()); // TODO(#4944): uncomment the following lines to revive full verification - // auto composer = AvmComposer(); - // auto prover = composer.create_prover(circuit_builder); - // auto proof = prover.construct_proof(); + auto composer = AvmComposer(); + auto prover = composer.create_prover(circuit_builder); + info("batched relation partial lengh:", AvmFlavor::BATCHED_RELATION_PARTIAL_LENGTH); + auto proof = prover.construct_proof(); + info("Proof size: {}", proof.size()); + + // info("Proof ", bytes_to_hex_string(to_buffer(proof))); - // auto verifier = composer.create_verifier(circuit_builder); - // bool verified = verifier.verify_proof(proof); + auto verifier = composer.create_verifier(circuit_builder); + bool verified = verifier.verify_proof(proof); - // EXPECT_TRUE(verified); + EXPECT_TRUE(verified); // if (!verified) { // avm_trace::log_avm_trace(circuit_builder.rows, 0, 10); From 8b88dcd6c5a266c4009a1de8c1c204777cddaffe Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 5 Apr 2024 18:51:40 +0000 Subject: [PATCH 3/6] fix: degree too low for lookup relations --- .../generated/avm/incl_main_tag_err.hpp | 2 +- .../generated/avm/incl_mem_tag_err.hpp | 2 +- .../generated/avm/lookup_byte_lengths.hpp | 2 +- .../generated/avm/lookup_byte_operations.hpp | 2 +- .../src/barretenberg/sumcheck/sumcheck.hpp | 3 +- .../barretenberg/sumcheck/sumcheck_round.hpp | 2 +- .../ultra_honk/ultra_verifier.cpp | 1 - .../barretenberg/vm/generated/avm_flavor.hpp | 7 ++-- .../barretenberg/vm/generated/avm_prover.cpp | 35 +------------------ .../vm/generated/avm_verifier.cpp | 9 ----- 10 files changed, 11 insertions(+), 54 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_main_tag_err.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_main_tag_err.hpp index 01e8335fd7e..cfb4885c4b5 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_main_tag_err.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_main_tag_err.hpp @@ -60,7 +60,7 @@ class incl_main_tag_err_lookup_settings { * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed * */ - static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 2; + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; /** * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_mem_tag_err.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_mem_tag_err.hpp index 94b43658059..4055ceb7951 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_mem_tag_err.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_mem_tag_err.hpp @@ -60,7 +60,7 @@ class incl_mem_tag_err_lookup_settings { * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed * */ - static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 2; + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; /** * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp index 4c5a6bd0d48..66268991c7c 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp @@ -60,7 +60,7 @@ class lookup_byte_lengths_lookup_settings { * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed * */ - static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 2; + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; /** * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp index 92874d3d134..baf2995fcb8 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp @@ -60,7 +60,7 @@ class lookup_byte_operations_lookup_settings { * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed * */ - static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 2; + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; /** * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read diff --git a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp index 2ff1721a9c8..bbf104425d6 100644 --- a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp +++ b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp @@ -103,7 +103,7 @@ template class SumcheckProver { pow_univariate.partially_evaluate(round_challenge); round.round_size = round.round_size >> 1; // TODO(#224)(Cody): Maybe partially_evaluate should do this and // release memory? // All but final round - // We operate on partially_evaluated_polynomials in place. + // We operate on partially_evaluated_polynomials in place. for (size_t round_idx = 1; round_idx < multivariate_d; round_idx++) { // Write the round univariate to the transcript round_univariate = @@ -122,7 +122,6 @@ template class SumcheckProver { zip_view(multivariate_evaluations.get_all(), partially_evaluated_polynomials.get_all())) { eval = poly[0]; } - info("Multivariate evaluations: {}", multivariate_evaluations.get_all().size()); transcript->send_to_verifier("Sumcheck:evaluations", multivariate_evaluations.get_all()); return { multivariate_challenge, multivariate_evaluations }; diff --git a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck_round.hpp b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck_round.hpp index 2a3441812d5..8360fe20f74 100644 --- a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck_round.hpp +++ b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck_round.hpp @@ -108,7 +108,7 @@ template class SumcheckProverRound { { BB_OP_COUNT_TIME(); - // Compute the constant contribution of pow polynomials for each edge. This is the product of the partial + // Compute the constant contribution of pow polynomials for each edge. This is the product of the partial // evaluation result c_l (i.e. pow(u_0,...,u_{l-1})) where u_0,...,u_{l-1} are the verifier challenges from // previous rounds) and the elements of pow(\vec{β}) not containing β_0,..., β_l. std::vector pow_challenges(round_size >> 1); diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp index 6d5b19761b8..1d16e1c8c42 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp @@ -82,7 +82,6 @@ template bool UltraVerifier_::verify_proof(const HonkP transcript); auto pcs_verified = key->pcs_verification_key->pairing_check(pairing_points[0], pairing_points[1]); return sumcheck_verified.value() && pcs_verified; - ; } template class UltraVerifier_; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 54529ea5174..6c109edd2dd 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -93,7 +93,7 @@ class AvmFlavor { // random polynomial e.g. For \sum(x) [A(x) * B(x) + C(x)] * PowZeta(X), relation length = 2 and random relation // length = 3 static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH = MAX_PARTIAL_RELATION_LENGTH + 1; - static constexpr size_t NUM_RELATIONS = std::tuple_size::value; + static constexpr size_t NUM_RELATIONS = std::tuple_size_v; template using ProtogalaxyTupleOfTuplesOfUnivariates = @@ -1126,10 +1126,10 @@ class AvmFlavor { this->pcs_verification_key = std::make_shared(); this->circuit_size = proving_key.circuit_size; this->log_circuit_size = numeric::get_msb(this->circuit_size); - this->num_public_inputs = proving_key.num_public_inputs; + // this->num_public_inputs = proving_key.num_public_inputs; // TODO(md): we shouldnt have this - this->pub_inputs_offset = proving_key.pub_inputs_offset; + // this->pub_inputs_offset = proving_key.pub_inputs_offset; for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) { commitment = proving_key.commitment_key->commit(polynomial); @@ -1211,6 +1211,7 @@ class AvmFlavor { */ using ExtendedEdges = ProverUnivariates; + // TODO: add derived entities + witness entities /** * @brief A container for the witness commitments. * diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index 811e300f40e..d456d6844a3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -48,7 +48,6 @@ void AvmProver::execute_preamble_round() const auto circuit_size = static_cast(key->circuit_size); transcript->send_to_verifier("circuit_size", circuit_size); - info("Sent circuit size to verifier: ", circuit_size); } /** @@ -57,18 +56,7 @@ void AvmProver::execute_preamble_round() */ void AvmProver::execute_wire_commitments_round() { - // auto wire_polys = key->get_wit_wires(); - - // // TEMP: fine just using wires here and not wit wires as the indexes should still line up - // auto labels = commitment_labels.get_wires(); - // for (size_t idx = 0; idx < wire_polys.size(); ++idx) { - // info("Committing to wire ", labels[idx]); - // transcript->send_to_verifier(labels[idx], commitment_key->commit(wire_polys[idx])); - // } - - // TODO: while debugging Temporarily manually commit to each wire - // All witness commitments - // TODO: check these -> was done with a macro + auto labels = commitment_labels; witness_commitments.avm_alu_alu_sel = commitment_key->commit(key->avm_alu_alu_sel); @@ -337,33 +325,17 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.lookup_byte_operations_counts); transcript->send_to_verifier(labels.incl_main_tag_err_counts, witness_commitments.incl_main_tag_err_counts); transcript->send_to_verifier(labels.incl_mem_tag_err_counts, witness_commitments.incl_mem_tag_err_counts); - - info("sent all witness contributions to the prover manually "); } void AvmProver::execute_log_derivative_inverse_round() { auto [beta, gamma] = transcript->template get_challenges("beta", "gamma"); - info("prover beta ", beta); - info("prover gamma ", gamma); - - auto beta_sqr = beta * beta; - auto beta_cube = beta_sqr * beta; relation_parameters.beta = beta; relation_parameters.gamma = gamma; - relation_parameters.beta_sqr = beta_sqr; - relation_parameters.beta_cube = beta_cube; - - // TODO: Add an implementation of this to the flavor - // We will need to compute -> the inverse for each column and add it to the proving key - // -> I think we should be able to use each of the bespoke lookup relations for this??? key->compute_logderivative_inverses(relation_parameters); - // Send each computed inverse to the verifier - // TODO(md): why is it computed within the flavor and not here? seems like it could be? - // Permutations witness_commitments.perm_main_alu = commitment_key->commit(key->perm_main_alu); witness_commitments.perm_main_bin = commitment_key->commit(key->perm_main_bin); @@ -393,8 +365,6 @@ void AvmProver::execute_log_derivative_inverse_round() transcript->send_to_verifier(commitment_labels.incl_mem_tag_err, witness_commitments.incl_mem_tag_err); transcript->send_to_verifier(commitment_labels.lookup_byte_lengths, witness_commitments.lookup_byte_lengths); transcript->send_to_verifier(commitment_labels.lookup_byte_operations, witness_commitments.lookup_byte_operations); - - info("lookup byte operations ", witness_commitments.lookup_byte_operations); } /** @@ -410,15 +380,12 @@ void AvmProver::execute_relation_check_rounds() auto sumcheck = Sumcheck(key->circuit_size, transcript); FF alpha = transcript->template get_challenge("Sumcheck:alpha"); - info("get msb ", numeric::get_msb(key->circuit_size)); std::vector gate_challenges(numeric::get_msb(key->circuit_size)); for (size_t idx = 0; idx < gate_challenges.size(); idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); - info("gate chall", gate_challenges[idx]); } sumcheck_output = sumcheck.prove(prover_polynomials, relation_parameters, alpha, gate_challenges); - // info("Sumcheck output ", sumcheck_output); } /** diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 6e21e0e6ca3..882ffbec552 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -47,10 +47,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) const auto circuit_size = transcript->template receive_from_prover("circuit_size"); if (circuit_size != key->circuit_size) { - info("circuit_size does not line up: {} != {}", circuit_size, key->circuit_size); return false; } - info("circuit_size has lined up: {}", circuit_size); // Get commitments to VM wires commitments.avm_alu_alu_sel = @@ -259,14 +257,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) commitments.incl_mem_tag_err_counts = transcript->template receive_from_prover(commitment_labels.incl_mem_tag_err_counts); - // TODO: Check that these all have values - // Calculate the alpha and beta challenges - log derivative inverse round auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); - - info("verifier beta = ", beta); - info("verifier gamma = ", gamm); - auto beta_sqr = beta * beta; auto beta_cube = beta_sqr * beta; relation_parameters.beta = beta; @@ -309,7 +301,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) auto gate_challenges = std::vector(log_circuit_size); for (size_t idx = 0; idx < log_circuit_size; idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); - info("verifier gate_challenges[", idx, "] = ", gate_challenges[idx]); } auto [multivariate_challenge, claimed_evaluations, sumcheck_verified] = From c8d9601c10e1a99252a95cd559b979af7e5e60f3 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 5 Apr 2024 18:54:27 +0000 Subject: [PATCH 4/6] chore: rename validate trace proof to check circuit, make another method for proof --- .../vm/tests/avm_arithmetic.test.cpp | 214 +++++++++--------- .../vm/tests/avm_bitwise.test.cpp | 26 +-- .../vm/tests/avm_control_flow.test.cpp | 8 +- .../vm/tests/avm_indirect_mem.test.cpp | 6 +- .../vm/tests/avm_inter_table.test.cpp | 42 ++-- .../vm/tests/avm_mem_opcodes.test.cpp | 18 +- .../barretenberg/vm/tests/avm_memory.test.cpp | 20 +- .../barretenberg/vm/tests/helpers.test.cpp | 37 +-- .../barretenberg/vm/tests/helpers.test.hpp | 1 + 9 files changed, 179 insertions(+), 193 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp index 6b4e422c891..c439cb57cd8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp @@ -334,7 +334,7 @@ TEST_F(AvmArithmeticTestsFF, addition) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over finite field type. @@ -354,7 +354,7 @@ TEST_F(AvmArithmeticTestsFF, subtraction) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); avm_trace::log_avm_trace(trace, 0, 10); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over finite field type. @@ -374,7 +374,7 @@ TEST_F(AvmArithmeticTestsFF, multiplication) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication by zero over finite field type. @@ -394,7 +394,7 @@ TEST_F(AvmArithmeticTestsFF, multiplicationByZero) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic division over finite field type. @@ -417,7 +417,7 @@ TEST_F(AvmArithmeticTestsFF, division) EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); EXPECT_EQ(row->avm_main_rwc, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on division with zero numerator over finite field type. @@ -440,7 +440,7 @@ TEST_F(AvmArithmeticTestsFF, divisionNumeratorZero) EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); EXPECT_EQ(row->avm_main_rwc, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on division by zero over finite field type. @@ -465,7 +465,7 @@ TEST_F(AvmArithmeticTestsFF, divisionByZeroError) EXPECT_EQ(row->avm_main_rwc, FF(1)); EXPECT_EQ(row->avm_main_op_err, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on division of zero by zero over finite field type. @@ -488,7 +488,7 @@ TEST_F(AvmArithmeticTestsFF, divisionZeroByZeroError) EXPECT_EQ(row->avm_main_rwc, FF(1)); EXPECT_EQ(row->avm_main_op_err, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing an execution of the different arithmetic opcodes over finite field @@ -513,7 +513,7 @@ TEST_F(AvmArithmeticTestsFF, mixedOperationsWithError) trace_builder.halt(); auto trace = trace_builder.finalize(); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test of equality on FF elements @@ -531,7 +531,7 @@ TEST_F(AvmArithmeticTestsFF, equality) EXPECT_EQ(alu_row.avm_alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); // Expect 0 as inv of (q-1) - (q-1) - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of FF elements @@ -548,7 +548,7 @@ TEST_F(AvmArithmeticTestsFF, nonEquality) EXPECT_EQ(alu_row.avm_alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-1).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -573,7 +573,7 @@ TEST_F(AvmArithmeticTestsU8, addition) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(91)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u8 type with carry. @@ -595,7 +595,7 @@ TEST_F(AvmArithmeticTestsU8, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(3)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u8 type. @@ -616,7 +616,7 @@ TEST_F(AvmArithmeticTestsU8, subtraction) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(133)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on subtraction over u8 type with carry. @@ -646,7 +646,7 @@ TEST_F(AvmArithmeticTestsU8, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u8 type. @@ -669,7 +669,7 @@ TEST_F(AvmArithmeticTestsU8, multiplication) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(195)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u8 type with overflow. @@ -693,7 +693,7 @@ TEST_F(AvmArithmeticTestsU8, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(208)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(132)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test of equality on u8 elements @@ -706,7 +706,7 @@ TEST_F(AvmArithmeticTestsU8, equality) EXPECT_EQ(alu_row.avm_alu_u8_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U8 elements @@ -719,7 +719,7 @@ TEST_F(AvmArithmeticTestsU8, nonEquality) EXPECT_EQ(alu_row.avm_alu_u8_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-116).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -745,7 +745,7 @@ TEST_F(AvmArithmeticTestsU16, addition) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0xDC)); // 34780 = 0x87DC EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0x87)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u16 type with carry. @@ -767,7 +767,7 @@ TEST_F(AvmArithmeticTestsU16, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(17)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u16 type. @@ -790,7 +790,7 @@ TEST_F(AvmArithmeticTestsU16, subtraction) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0x79)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u16 type with carry. @@ -820,7 +820,7 @@ TEST_F(AvmArithmeticTestsU16, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u16 type. @@ -845,7 +845,7 @@ TEST_F(AvmArithmeticTestsU16, multiplication) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0xBF)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u16 type with overflow. @@ -871,7 +871,7 @@ TEST_F(AvmArithmeticTestsU16, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(8)); EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test of equality on U16 elements @@ -884,7 +884,7 @@ TEST_F(AvmArithmeticTestsU16, equality) EXPECT_EQ(alu_row.avm_alu_u16_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U16 elements @@ -897,7 +897,7 @@ TEST_F(AvmArithmeticTestsU16, nonEquality) EXPECT_EQ(alu_row.avm_alu_u16_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-14'300).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -924,7 +924,7 @@ TEST_F(AvmArithmeticTestsU32, addition) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF((2234567891LLU >> 8) & UINT8_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(2234567891LLU >> 16)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u32 type with carry. @@ -946,7 +946,7 @@ TEST_F(AvmArithmeticTestsU32, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(231)); // 999 = 3 * 256 + 231 EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(3)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u32 type. @@ -972,7 +972,7 @@ TEST_F(AvmArithmeticTestsU32, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0x69F)); EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u32 type with carry. @@ -1004,7 +1004,7 @@ TEST_F(AvmArithmeticTestsU32, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u32 type. @@ -1033,7 +1033,7 @@ TEST_F(AvmArithmeticTestsU32, multiplication) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u32 type with overflow. @@ -1062,7 +1062,7 @@ TEST_F(AvmArithmeticTestsU32, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(71)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test of equality on U32 elements @@ -1076,7 +1076,7 @@ TEST_F(AvmArithmeticTestsU32, equality) EXPECT_EQ(alu_row.avm_alu_u32_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U32 elements @@ -1090,7 +1090,7 @@ TEST_F(AvmArithmeticTestsU32, nonEquality) EXPECT_EQ(alu_row.avm_alu_u32_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(1).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -1124,7 +1124,7 @@ TEST_F(AvmArithmeticTestsU64, addition) EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0x3684)); EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0x24)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u64 type with carry. @@ -1152,7 +1152,7 @@ TEST_F(AvmArithmeticTestsU64, additionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u64 type. @@ -1183,7 +1183,7 @@ TEST_F(AvmArithmeticTestsU64, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0X23)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u64 type with carry. @@ -1216,7 +1216,7 @@ TEST_F(AvmArithmeticTestsU64, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r4, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u64 type. @@ -1245,7 +1245,7 @@ TEST_F(AvmArithmeticTestsU64, multiplication) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0x7B5)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u64 type with overflow. @@ -1280,7 +1280,7 @@ TEST_F(AvmArithmeticTestsU64, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmArithmeticTestsU64, equality) @@ -1293,7 +1293,7 @@ TEST_F(AvmArithmeticTestsU64, equality) EXPECT_EQ(alu_row.avm_alu_u64_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U64 elements @@ -1307,7 +1307,7 @@ TEST_F(AvmArithmeticTestsU64, nonEquality) EXPECT_EQ(alu_row.avm_alu_u64_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0x510000).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -1350,7 +1350,7 @@ TEST_F(AvmArithmeticTestsU128, addition) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0x4444)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0x8888)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u128 type with carry. @@ -1390,7 +1390,7 @@ TEST_F(AvmArithmeticTestsU128, additionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0xFFFF)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0xFFFF)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u128 type. @@ -1432,7 +1432,7 @@ TEST_F(AvmArithmeticTestsU128, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r7, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u128 type with carry. @@ -1472,7 +1472,7 @@ TEST_F(AvmArithmeticTestsU128, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0x2222)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u128 type. @@ -1506,7 +1506,7 @@ TEST_F(AvmArithmeticTestsU128, multiplication) EXPECT_EQ(alu_row_second.avm_alu_u16_r1, FF(0x762C)); EXPECT_EQ(alu_row_second.avm_alu_u16_r2, FF(0xF92C)); EXPECT_EQ(alu_row_second.avm_alu_u16_r3, FF(0x1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u128 type with overflow. @@ -1566,7 +1566,7 @@ TEST_F(AvmArithmeticTestsU128, multiplicationOverflow) EXPECT_EQ(alu_row_first.avm_alu_u64_r0, FF{ UINT64_MAX - 6 }); // 2^64 - 7 EXPECT_EQ(alu_row_first.avm_alu_cf, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmArithmeticTestsU128, equality) @@ -1586,7 +1586,7 @@ TEST_F(AvmArithmeticTestsU128, equality) EXPECT_EQ(alu_row.avm_alu_u128_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U128 elements @@ -1608,7 +1608,7 @@ TEST_F(AvmArithmeticTestsU128, nonEquality) EXPECT_EQ(alu_row.avm_alu_u128_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0xdeadbeefLLU << 32).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -1640,21 +1640,21 @@ TEST_F(AvmArithmeticTestsU128, nonEquality) TEST_F(AvmArithmeticNegativeTestsFF, addition) { auto trace = gen_mutated_trace_add(FF(37), FF(4), FF(40), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_1"); } // Test on basic incorrect subtraction over finite field type. TEST_F(AvmArithmeticNegativeTestsFF, subtraction) { auto trace = gen_mutated_trace_sub(FF(17), FF(8), FF(-9), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_1"); } // Test on basic incorrect multiplication over finite field type. TEST_F(AvmArithmeticNegativeTestsFF, multiplication) { auto trace = gen_mutated_trace_mul(FF(9), FF(100), FF(9000000), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MULTIPLICATION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MULTIPLICATION_FF"); } // Test on basic incorrect division over finite field type. @@ -1670,7 +1670,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, divisionFF) auto select_row = [](Row r) { return r.avm_main_sel_op_div == FF(1); }; mutate_ic_in_trace(trace, std::move(select_row), FF(0)); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_DIVISION_FF"); } // Test where division is not by zero but an operation error is wrongly raised @@ -1693,11 +1693,11 @@ TEST_F(AvmArithmeticNegativeTestsFF, divisionNoZeroButError) trace[index].avm_main_op_err = FF(1); auto trace2 = trace; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); // Even more malicious, one makes the first relation passes by setting the inverse to zero. trace2[index].avm_main_inv = FF(0); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace2)), "SUBOP_DIVISION_ZERO_ERR2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace2)), "SUBOP_DIVISION_ZERO_ERR2"); } // Test with division by zero occurs and no error is raised (remove error flag) @@ -1716,7 +1716,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, divisionByZeroNoError) // Remove the operator error flag row->avm_main_op_err = FF(0); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_DIVISION_FF"); } // Test with division of zero by zero occurs and no error is raised (remove error flag) @@ -1733,7 +1733,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, divisionZeroByZeroNoError) // Remove the operator error flag row->avm_main_op_err = FF(0); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); } // Test that error flag cannot be raised for a non-relevant operation such as @@ -1754,7 +1754,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, operationWithErrorFlag) // Activate the operator error row->avm_main_op_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); trace_builder.reset(); @@ -1771,7 +1771,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, operationWithErrorFlag) // Activate the operator error row->avm_main_op_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); trace_builder.reset(); @@ -1788,14 +1788,14 @@ TEST_F(AvmArithmeticNegativeTestsFF, operationWithErrorFlag) // Activate the operator error row->avm_main_op_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); } // Tests a situation for field elements where a != b but c == 1; TEST_F(AvmArithmeticNegativeTestsFF, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF::modulus_minus_two, FF(0), FF(1), FF(0), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for field elements where a == b but c == 0; @@ -1803,7 +1803,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF::modulus_minus_two, FF::modulus_minus_two, FF(0), FF(0), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for field elements where c is non-boolean, i,e, c!= {0,1}; @@ -1811,7 +1811,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF::modulus_minus_two, FF::modulus_minus_two, FF(10), FF(0), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for field elements where the tag for c is not U8. @@ -1828,7 +1828,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(4); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for field elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -1837,7 +1837,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, invalidInverseDifference) // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(FF::modulus_minus_two, FF(0), FF(0), FF(5).invert(), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** @@ -1848,42 +1848,42 @@ TEST_F(AvmArithmeticNegativeTestsFF, invalidInverseDifference) TEST_F(AvmArithmeticNegativeTestsU8, addition) { auto trace = gen_mutated_trace_add(FF(234), FF(22), FF(1), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U8. TEST_F(AvmArithmeticNegativeTestsU8, subtraction) { auto trace = gen_mutated_trace_sub(FF(100), FF(104), FF(253), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U8. TEST_F(AvmArithmeticNegativeTestsU8, multiplication) { auto trace = gen_mutated_trace_mul(FF(9), FF(100), FF(55), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MUL_COMMON_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MUL_COMMON_2"); } // Tests a situation for U8 elements where a != b but c == 1; TEST_F(AvmArithmeticNegativeTestsU8, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF(10), FF(255), FF(1), FF(0), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U8 elements where a == b but c == 0; TEST_F(AvmArithmeticNegativeTestsU8, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF(128), FF(128), FF(0), FF(0), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U8 elements where c is non-boolean, i,e, c!= {0,1}; TEST_F(AvmArithmeticNegativeTestsU8, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF(128), FF(128), FF(200), FF(0), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U8 elements where the tag for c is not U8. @@ -1896,7 +1896,7 @@ TEST_F(AvmArithmeticNegativeTestsU8, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(3); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U8 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -1904,7 +1904,7 @@ TEST_F(AvmArithmeticNegativeTestsU8, invalidInverseDifference) { // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(FF(130), FF(0), FF(0), FF(1000).invert(), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** @@ -1915,42 +1915,42 @@ TEST_F(AvmArithmeticNegativeTestsU8, invalidInverseDifference) TEST_F(AvmArithmeticNegativeTestsU16, addition) { auto trace = gen_mutated_trace_add(FF(8234), FF(7428), FF(653), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U16. TEST_F(AvmArithmeticNegativeTestsU16, subtraction) { auto trace = gen_mutated_trace_sub(FF(100), FF(932), FF(25373), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U16. TEST_F(AvmArithmeticNegativeTestsU16, multiplication) { auto trace = gen_mutated_trace_mul(FF(8096), FF(1024), FF(1), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MUL_COMMON_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MUL_COMMON_2"); } // Tests a situation for U16 elements where a != b but c == 1; TEST_F(AvmArithmeticNegativeTestsU16, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF(10), FF(255), FF(1), FF(0), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U16 elements where a == b but c == 0; TEST_F(AvmArithmeticNegativeTestsU16, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF(128), FF(128), FF(0), FF(0), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U16 elements where c is non-boolean, i,e, c!= {0,1}; TEST_F(AvmArithmeticNegativeTestsU16, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF(128), FF(128), FF(200), FF(0), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U16 elements where the tag for c is not U8. @@ -1963,7 +1963,7 @@ TEST_F(AvmArithmeticNegativeTestsU16, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(5); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U16 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -1971,7 +1971,7 @@ TEST_F(AvmArithmeticNegativeTestsU16, invalidInverseDifference) { // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(FF(130), FF(0), FF(0), FF(1000).invert(), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** * Negative Tests - U32 @@ -1981,35 +1981,35 @@ TEST_F(AvmArithmeticNegativeTestsU16, invalidInverseDifference) TEST_F(AvmArithmeticNegativeTestsU32, addition) { auto trace = gen_mutated_trace_add(FF(1972382341), FF(1111133221), FF(1222222222), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U32. TEST_F(AvmArithmeticNegativeTestsU32, subtraction) { auto trace = gen_mutated_trace_sub(FF(3999888777LLU), FF(UINT32_MAX), FF(2537332433LLU), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U32. TEST_F(AvmArithmeticNegativeTestsU32, multiplication) { auto trace = gen_mutated_trace_mul(FF(UINT32_MAX), FF(UINT32_MAX), FF(0), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MUL_COMMON_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MUL_COMMON_2"); } // Tests a situation for U32 elements where a != b but c == 1; TEST_F(AvmArithmeticNegativeTestsU32, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF(UINT32_MAX - 10), FF(UINT32_MAX), FF(1), FF(0), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U32 elements where a == b but c == 0; TEST_F(AvmArithmeticNegativeTestsU32, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF(73934721LLU), FF(73934721LLU), FF(0), FF(0), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U32 elements where c is non-boolean, i,e, c!= {0,1}; @@ -2017,7 +2017,7 @@ TEST_F(AvmArithmeticNegativeTestsU32, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF(623138LLU), FF(623138LLU), FF(8728342LLU), FF(0), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U32 elements where the tag for c is not U8. @@ -2030,7 +2030,7 @@ TEST_F(AvmArithmeticNegativeTestsU32, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(6); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U32 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2039,7 +2039,7 @@ TEST_F(AvmArithmeticNegativeTestsU32, invalidInverseDifference) // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(FF(74329231LLU), FF(74329231LLU), FF(0), FF(7432701LLU).invert(), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** @@ -2051,7 +2051,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, addition) { auto trace = gen_mutated_trace_add( FF(3324236423198282341LLU), FF(999999991111133221LLU), FF(1222222222236LLU), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U64. @@ -2059,7 +2059,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, subtraction) { auto trace = gen_mutated_trace_sub(FF(399988877723434LLU), FF(UINT64_MAX), FF(25373324332342LLU), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U64. @@ -2067,7 +2067,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, multiplication) { auto trace = gen_mutated_trace_mul(FF(399988877723434LLU), FF(9998887772343LLU), FF(9283674827534LLU), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MUL_COMMON_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MUL_COMMON_2"); } // Tests a situation for U64 elements where a != b but c == 1; @@ -2075,7 +2075,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF(3999888777231234LLU), FF(3999882177231234LLU), FF(1), FF(0), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U64 elements where a == b but c == 0; @@ -2083,7 +2083,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF(9998887772343LLU), FF(73934721LLU), FF(0), FF(0), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U64 elements where c is non-boolean, i,e, c!= {0,1}; @@ -2091,7 +2091,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF(9998887772343LLU), FF(9998887772343LLU), FF(2), FF(0), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U64 elements where the tag for c is not U8. @@ -2104,7 +2104,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(2); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U64 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2113,7 +2113,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, invalidInverseDifference) // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq( FF(9998887772343LLU), FF(9998887772343LLU), FF(0), FF(0x373428).invert(), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** @@ -2131,7 +2131,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, addition) FF{ uint256_t::from_uint128(b) }, FF{ uint256_t::from_uint128(c) }, AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U128. @@ -2145,7 +2145,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, subtraction) FF{ uint256_t::from_uint128(b) }, FF{ uint256_t::from_uint128(c) }, AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U128. @@ -2159,7 +2159,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, multiplication) FF{ uint256_t::from_uint128(b) }, FF{ uint256_t::from_uint128(c) }, AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MULTIPLICATION_OUT_U128"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MULTIPLICATION_OUT_U128"); } // Tests a situation for U128 elements where a != b but c == 1; @@ -2171,7 +2171,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, invalidEquality) FF const ff_b = FF{ uint256_t::from_uint128(b) }; std::vector trace = gen_mutated_trace_eq(ff_a, ff_b, FF(1), FF(0), AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U128 elements where a == b but c == 0; @@ -2181,7 +2181,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, invalidInequality) FF const ff_a = FF{ uint256_t::from_uint128(a) }; std::vector trace = gen_mutated_trace_eq(ff_a, ff_a, FF(0), FF(0), AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U128 elements where c is non-boolean, i,e, c!= {0,1}; @@ -2190,7 +2190,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, nonBooleanEq) uint128_t const a = (uint128_t{ 0x5555222233334444LLU } << 64) + uint128_t{ 0x88889999AAAABBBBLLU }; FF const ff_a = FF{ uint256_t::from_uint128(a) }; std::vector trace = gen_mutated_trace_eq(ff_a, ff_a, FF::modulus - FF(1), FF(0), AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U128 elements where the tag for c is not U8. @@ -2203,7 +2203,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(4); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U128 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2213,7 +2213,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, invalidInverseDifference) FF const ff_a = FF{ uint256_t::from_uint128(a) }; // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(ff_a, ff_a, FF(0), FF(0x8efaddd292LLU).invert(), AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp index 37d10a62712..13556db5d22 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp @@ -355,7 +355,7 @@ TEST_P(AvmBitwiseTestsNot, ParamTest) FF ff_a = FF(uint256_t::from_uint128(a)); FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_op_not(trace, ff_a, ff_output, FF(0), FF(1), mem_tag); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, @@ -377,7 +377,7 @@ TEST_P(AvmBitwiseTestsAnd, AllAndTest) FF ff_output = FF(uint256_t::from_uint128(output)); // EXPECT_EQ(1, 2) << "a ^ b " << (a ^ b) << '\n'; common_validate_bit_op(trace, 0, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsAnd, @@ -398,7 +398,7 @@ TEST_P(AvmBitwiseTestsOr, AllOrTest) FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_bit_op(trace, 1, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsOr, @@ -419,7 +419,7 @@ TEST_P(AvmBitwiseTestsXor, AllXorTest) FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_bit_op(trace, 2, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, @@ -481,7 +481,7 @@ TEST_P(AvmBitwiseNegativeTestsAnd, AllNegativeTests) FF ff_output = FF(uint256_t::from_uint128(output)); std::function&& select_row = [](Row r) { return r.avm_main_sel_op_and == FF(1); }; trace = gen_mutated_trace_bit(trace, std::move(select_row), ff_output, failure_mode); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), failure_string); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), failure_string); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseNegativeTests, AvmBitwiseNegativeTestsAnd, @@ -502,7 +502,7 @@ TEST_P(AvmBitwiseNegativeTestsOr, AllNegativeTests) FF ff_output = FF(uint256_t::from_uint128(output)); std::function&& select_row = [](Row r) { return r.avm_main_sel_op_or == FF(1); }; trace = gen_mutated_trace_bit(trace, std::move(select_row), ff_output, failure_mode); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), failure_string); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), failure_string); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseNegativeTests, AvmBitwiseNegativeTestsOr, @@ -522,7 +522,7 @@ TEST_P(AvmBitwiseNegativeTestsXor, AllNegativeTests) FF ff_output = FF(uint256_t::from_uint128(output)); std::function&& select_row = [](Row r) { return r.avm_main_sel_op_xor == FF(1); }; trace = gen_mutated_trace_bit(trace, std::move(select_row), ff_output, failure_mode); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), failure_string) + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), failure_string) } INSTANTIATE_TEST_SUITE_P(AvmBitwiseNegativeTests, AvmBitwiseNegativeTestsXor, @@ -553,32 +553,32 @@ TEST_F(AvmBitwiseNegativeTestsFF, UndefinedOverFF) trace.at(i).avm_alu_in_tag = FF(6); } - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_FF_NOT_XOR"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_FF_NOT_XOR"); } TEST_F(AvmBitwiseNegativeTestsU8, BitwiseNot) { std::vector trace = gen_mutated_trace_not(FF{ 1 }, FF{ 2 }, AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } TEST_F(AvmBitwiseNegativeTestsU16, BitwiseNot) { std::vector trace = gen_mutated_trace_not(FF{ 32'768 }, FF{ 8'192 }, AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } TEST_F(AvmBitwiseNegativeTestsU32, BitwiseNot) { std::vector trace = gen_mutated_trace_not(FF{ 0xdeadbeef }, FF{ 0x20020af }, AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } TEST_F(AvmBitwiseNegativeTestsU64, BitwiseNot) { std::vector trace = gen_mutated_trace_not(FF{ 0x10000000000000LLU }, FF{ 0x10000fed0100000LLU }, AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } TEST_F(AvmBitwiseNegativeTestsU128, BitwiseNot) @@ -587,6 +587,6 @@ TEST_F(AvmBitwiseNegativeTestsU128, BitwiseNot) uint128_t const b = uint128_t{ 0x300000ae921000 } << 64; std::vector trace = gen_mutated_trace_not(FF{ uint256_t::from_uint128(a) }, FF{ uint256_t::from_uint128(b) }, AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp index 8ac2da28f08..b721f65f5b9 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp @@ -54,7 +54,7 @@ TEST_F(AvmControlFlowTests, simpleCall) EXPECT_EQ(halt_row->avm_main_pc, FF(CALL_ADDRESS)); EXPECT_EQ(halt_row->avm_main_internal_return_ptr, FF(AvmTraceBuilder::CALLSTACK_OFFSET + 1)); } - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmControlFlowTests, simpleJump) @@ -87,7 +87,7 @@ TEST_F(AvmControlFlowTests, simpleJump) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avm_main_pc, FF(JUMP_ADDRESS)); } - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmControlFlowTests, simpleCallAndReturn) @@ -137,7 +137,7 @@ TEST_F(AvmControlFlowTests, simpleCallAndReturn) EXPECT_EQ(halt_row->avm_main_pc, FF(RETURN_ADDRESS)); } - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmControlFlowTests, multipleCallsAndReturns) @@ -280,6 +280,6 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avm_main_pc, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp index e15356d5ae7..ab031397975 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp @@ -63,7 +63,7 @@ TEST_F(AvmIndirectMemTests, allIndirectAdd) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing a subtraction operation with direct input operands a, b, and an indirect @@ -109,7 +109,7 @@ TEST_F(AvmIndirectMemTests, indirectOutputSub) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing a multiplication operation with indirect input operand a, @@ -155,7 +155,7 @@ TEST_F(AvmIndirectMemTests, indirectInputAMul) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp index f2292cf5cac..f44e30d2fe8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp @@ -70,7 +70,7 @@ TEST_F(AvmInterTableTests, tagErrNotCopiedInMain) // Adjust the output in the memory trace. mem_row->avm_mem_val = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "INCL_MAIN_TAG_ERR"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "INCL_MAIN_TAG_ERR"); } /****************************************************************************** @@ -127,7 +127,7 @@ TEST_F(AvmPermMainAluNegativeTests, wrongAluOutputCopyInMain) trace.at(main_idx).avm_main_ic = 1008; trace.at(mem_idx).avm_mem_val = 1008; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIaInput) @@ -138,7 +138,7 @@ TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIaInput) trace.at(alu_idx).avm_alu_u8_r0 = 36; // 1060 % 256 = 36 trace.at(alu_idx).avm_alu_u8_r1 = 4; // 4 * 256 = 1024 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIbInput) @@ -149,7 +149,7 @@ TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIbInput) trace.at(alu_idx).avm_alu_u8_r0 = 190; trace.at(alu_idx).avm_alu_u8_r1 = 0; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluOpSelector) @@ -160,7 +160,7 @@ TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluOpSelector) trace.at(alu_idx).avm_alu_u8_r0 = 72; trace.at(alu_idx).avm_alu_u8_r1 = 0; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, removeAluSelector) @@ -168,7 +168,7 @@ TEST_F(AvmPermMainAluNegativeTests, removeAluSelector) trace.at(alu_idx).avm_alu_alu_sel = 0; trace.at(alu_idx).avm_alu_op_mul = 0; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } /****************************************************************************** @@ -237,7 +237,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIaInMem) trace.at(mem_idx_a).avm_mem_val = 26; // Correct value: 21 trace.at(mem_idx_a - 1).avm_mem_val = 26; // We need to adjust the write operation beforehand (set opcode). - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongValueIbInMem) @@ -246,7 +246,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIbInMem) trace.at(mem_idx_b).avm_mem_val = 7; // Correct value: 3 trace.at(mem_idx_b - 1).avm_mem_val = 7; // We need to adjust the write operation beforehand (set opcode). - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongValueIcInMem) @@ -254,7 +254,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIcInMem) executeSub(21, 3); trace.at(mem_idx_c).avm_mem_val = 17; // Correct value: 18 = 21 - 3 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } TEST_F(AvmPermMainMemNegativeTests, wrongAddressIaInMain) @@ -262,7 +262,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIaInMain) executeSub(21, 3); trace.at(main_idx).avm_main_mem_idx_a = 28; // Correct address: 52 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongAddressIbInMain) @@ -270,7 +270,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIbInMain) executeSub(21, 3); trace.at(main_idx).avm_main_mem_idx_b = 2; // Correct address: 11 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongAddressIcInMain) @@ -278,7 +278,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIcInMain) executeSub(21, 3); trace.at(main_idx).avm_main_mem_idx_c = 75; // Correct address: 55 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } TEST_F(AvmPermMainMemNegativeTests, wrongInTagIaInMem) @@ -293,7 +293,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIaInMem) trace.at(mem_idx_a - 1).avm_mem_w_in_tag = wrong_in_tag; trace.at(mem_idx_a - 1).avm_mem_tag = wrong_in_tag; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongInTagIbInMem) @@ -308,7 +308,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIbInMem) trace.at(mem_idx_b - 1).avm_mem_w_in_tag = wrong_in_tag; trace.at(mem_idx_b - 1).avm_mem_tag = wrong_in_tag; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongInTagIcInMem) @@ -318,7 +318,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIcInMem) trace.at(mem_idx_c).avm_mem_w_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 trace.at(mem_idx_c).avm_mem_tag = wrong_in_tag; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } TEST_F(AvmPermMainMemNegativeTests, wrongRwIaInMem) @@ -329,7 +329,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIaInMem) // Adjust sub_clk value trace.at(mem_idx_a).avm_mem_sub_clk = AvmMemTraceBuilder::SUB_CLK_STORE_A; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongRwIbInMem) @@ -340,7 +340,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIbInMem) // Adjust sub_clk value trace.at(mem_idx_b).avm_mem_sub_clk = AvmMemTraceBuilder::SUB_CLK_STORE_B; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongRwIcInMem) @@ -354,7 +354,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIcInMem) // Adjust sub_clk value trace.at(mem_idx_c).avm_mem_sub_clk = AvmMemTraceBuilder::SUB_CLK_LOAD_C; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } TEST_F(AvmPermMainMemNegativeTests, wrongClkIaInMem) @@ -362,7 +362,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIaInMem) executeSub(87, 23); trace.at(mem_idx_a).avm_mem_clk = 11; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongClkIbInMem) @@ -370,7 +370,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIbInMem) executeSub(87, 23); trace.at(mem_idx_b).avm_mem_clk = 21; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongClkIcInMem) @@ -378,7 +378,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIcInMem) executeSub(87, 23); trace.at(mem_idx_c).avm_mem_clk = 7; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp index cb66a0f32b2..56af4b53c39 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp @@ -147,7 +147,7 @@ class AvmMemOpcodeTests : public ::testing::Test { Field(&Row::avm_mem_ind_op_c, 1))); } - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } }; @@ -218,7 +218,7 @@ TEST_F(AvmMemOpcodeTests, indirectMovInvalidAddressTag) Field(&Row::avm_mem_r_in_tag, static_cast(AvmMemoryTag::U32)), Field(&Row::avm_mem_ind_op_c, 1))); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -233,7 +233,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputErrorTag) computeIndices(false); trace.at(main_idx).avm_main_tag_err = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "INCL_MEM_TAG_ERR"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "INCL_MEM_TAG_ERR"); } TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputValue) @@ -242,7 +242,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputValue) computeIndices(false); trace.at(main_idx).avm_main_ic = 233; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MOV_SAME_VALUE"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE"); } TEST_F(AvmMemOpcodeNegativeTests, indMovWrongOutputValue) @@ -251,7 +251,7 @@ TEST_F(AvmMemOpcodeNegativeTests, indMovWrongOutputValue) computeIndices(true); trace.at(main_idx).avm_main_ic = 8733; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MOV_SAME_VALUE"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE"); } // We want to test that the output tag for MOV cannot be altered. @@ -278,7 +278,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagLoadIa) trace.at(main_idx).avm_main_w_in_tag = tag_u64; trace.at(main_idx).avm_main_tag_err = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MOV_SAME_TAG"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_TAG"); } // Same as above but one tries to disable the selector of MOV opcode in @@ -304,7 +304,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagDisabledSelector) trace.at(main_idx).avm_main_w_in_tag = tag_u64; trace.at(main_idx).avm_main_tag_err = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } // Same goal as above but we alter the w_in_tag in the main trace @@ -321,7 +321,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagInMainTrace) trace.at(main_idx).avm_main_w_in_tag = tag_u64; trace.at(main_idx).avm_main_tag_err = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MOV_MAIN_SAME_TAG"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_MAIN_SAME_TAG"); } // The manipulation of the tag occurs in the store operation. @@ -335,7 +335,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagMainTraceRead) trace.at(mem_c_idx).avm_mem_tag = tag_u64; trace.at(mem_c_idx).avm_mem_w_in_tag = tag_u64; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp index a4f8ae95e1e..5a5b4659d65 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp @@ -69,7 +69,7 @@ TEST_F(AvmMemoryTests, mismatchedTagAddOperation) EXPECT_EQ(row->avm_mem_r_in_tag, FF(static_cast(AvmMemoryTag::U8))); EXPECT_EQ(row->avm_mem_tag, FF(static_cast(AvmMemoryTag::FF))); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing an equality operation with a mismatched memory tag. @@ -112,7 +112,7 @@ TEST_F(AvmMemoryTests, mismatchedTagEqOperation) EXPECT_EQ(row->avm_mem_r_in_tag, FF(static_cast(AvmMemoryTag::U32))); EXPECT_EQ(row->avm_mem_tag, FF(static_cast(AvmMemoryTag::U16))); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing violation that m_lastAccess is a delimiter for two different addresses @@ -143,7 +143,7 @@ TEST_F(AvmMemoryTests, mLastAccessViolation) row->avm_mem_lastAccess = FF(0); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_LAST_ACCESS_DELIMITER"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_LAST_ACCESS_DELIMITER"); } // Testing violation that a memory read operation must read the same value which was @@ -173,7 +173,7 @@ TEST_F(AvmMemoryTests, readWriteConsistencyValViolation) EXPECT_TRUE(row != trace.end()); row->avm_mem_val = FF(35); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_READ_WRITE_VAL_CONSISTENCY"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_READ_WRITE_VAL_CONSISTENCY"); } // Testing violation that memory read operation must read the same tag which was @@ -204,7 +204,7 @@ TEST_F(AvmMemoryTests, readWriteConsistencyTagViolation) row->avm_mem_tag = static_cast(AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_READ_WRITE_TAG_CONSISTENCY"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_READ_WRITE_TAG_CONSISTENCY"); } // Testing violation that a memory read at uninitialized location must have value 0. @@ -215,7 +215,7 @@ TEST_F(AvmMemoryTests, readUninitializedMemoryViolation) trace[1].avm_mem_val = 9; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_ZERO_INIT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_ZERO_INIT"); } // Testing violation that an operation with a mismatched memory tag @@ -244,12 +244,12 @@ TEST_F(AvmMemoryTests, mismatchedTagErrorViolation) auto index = static_cast(row - trace.begin()); auto trace2 = trace; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); // More sophisticated attempt by adapting witness "on_min_inv" to make pass the above constraint trace2[index].avm_mem_one_min_inv = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace2)), "MEM_IN_TAG_CONSISTENCY_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace2)), "MEM_IN_TAG_CONSISTENCY_2"); } // Testing violation that an operation with a consistent memory tag @@ -276,7 +276,7 @@ TEST_F(AvmMemoryTests, consistentTagNoErrorViolation) row->avm_mem_tag_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); } // Testing violation that a write operation must not set a VM error. @@ -303,7 +303,7 @@ TEST_F(AvmMemoryTests, noErrorTagWriteViolation) ASSERT_TRUE(row != trace.end()); row->avm_mem_tag_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "NO_TAG_ERR_WRITE"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "NO_TAG_ERR_WRITE"); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 978ac87f12e..b6884a49c20 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -3,25 +3,19 @@ #include #include -// TODO: remove this -std::string bytes_to_hex_string(const std::vector& input) +namespace tests_avm { +/** + * @brief Helper routine proving and verifying a proof based on the supplied trace + * + * @param trace The execution trace + */ +void validate_trace_check_circuit(std::vector&& trace) { - static const char characters[] = "0123456789ABCDEF"; - - // Zeroes out the buffer unnecessarily, can't be avoided for std::string. - std::string ret(input.size() * 2, 0); - - // Hack... Against the rules but avoids copying the whole buffer. - auto buf = const_cast(ret.data()); - - for (const auto& oneInputByte : input) { - *buf++ = characters[oneInputByte >> 4]; - *buf++ = characters[oneInputByte & 0x0F]; - } - return ret; -} + auto circuit_builder = AvmCircuitBuilder(); + circuit_builder.set_trace(std::move(trace)); + EXPECT_TRUE(circuit_builder.check_circuit()); +}; -namespace tests_avm { /** * @brief Helper routine proving and verifying a proof based on the supplied trace * @@ -33,23 +27,14 @@ void validate_trace_proof(std::vector&& trace) circuit_builder.set_trace(std::move(trace)); EXPECT_TRUE(circuit_builder.check_circuit()); - // TODO(#4944): uncomment the following lines to revive full verification auto composer = AvmComposer(); auto prover = composer.create_prover(circuit_builder); - info("batched relation partial lengh:", AvmFlavor::BATCHED_RELATION_PARTIAL_LENGTH); auto proof = prover.construct_proof(); - info("Proof size: {}", proof.size()); - - // info("Proof ", bytes_to_hex_string(to_buffer(proof))); auto verifier = composer.create_verifier(circuit_builder); bool verified = verifier.verify_proof(proof); EXPECT_TRUE(verified); - - // if (!verified) { - // avm_trace::log_avm_trace(circuit_builder.rows, 0, 10); - // } }; /** diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp index c794f7c5e13..0116ccaf538 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp @@ -16,6 +16,7 @@ using Flavor = bb::AvmFlavor; using FF = Flavor::FF; using Row = bb::AvmFullRow; +void validate_trace_check_circuit(std::vector&& trace); void validate_trace_proof(std::vector&& trace); void mutate_ic_in_trace(std::vector& trace, std::function&& selectRow, From c6959059435100a08dee1f22be1c326ef61981c9 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 5 Apr 2024 18:55:51 +0000 Subject: [PATCH 5/6] chore: remove dangling code --- .../barretenberg/vm/generated/avm_flavor.hpp | 19 ------------------- 1 file changed, 19 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 6c109edd2dd..7089601c2a3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -1072,16 +1072,6 @@ class AvmFlavor { { ProverPolynomials prover_polynomials = ProverPolynomials(*this); - // perm_main_alu_relation, - // perm_main_bin_relation, - // perm_main_mem_a_relation, - // perm_main_mem_b_relation, - // perm_main_mem_c_relation, - // perm_main_mem_ind_a_relation, - // perm_main_mem_ind_b_relation, - // perm_main_mem_ind_c_relation>; - - // One of these for each bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( @@ -1106,14 +1096,9 @@ class AvmFlavor { prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - - // TODO: check if this has set the inverse for each of the polys - info("Computed logderivative inverses for all relations"); } }; - // TODO: altered this to be a class - // using VerificationKey = VerificationKey_, VerifierCommitmentKey>; class VerificationKey : public VerificationKey_, VerifierCommitmentKey> { public: VerificationKey() = default; @@ -1126,10 +1111,6 @@ class AvmFlavor { this->pcs_verification_key = std::make_shared(); this->circuit_size = proving_key.circuit_size; this->log_circuit_size = numeric::get_msb(this->circuit_size); - // this->num_public_inputs = proving_key.num_public_inputs; - - // TODO(md): we shouldnt have this - // this->pub_inputs_offset = proving_key.pub_inputs_offset; for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) { commitment = proving_key.commitment_key->commit(polynomial); From 619175bd85f8df452d1f55cb3a786451f2b4d376 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 5 Apr 2024 19:23:56 +0000 Subject: [PATCH 6/6] chore: further cleanup --- .../barretenberg/ultra_honk/ultra_prover.cpp | 1 - .../vm/generated/avm_circuit_builder.hpp | 14 -- .../vm/generated/avm_composer.cpp | 1 - .../vm/generated/avm_composer.hpp | 1 - .../barretenberg/vm/generated/avm_flavor.hpp | 149 ------------------ .../barretenberg/vm/generated/avm_prover.cpp | 2 - .../vm/generated/avm_verifier.cpp | 4 - .../barretenberg/vm/tests/helpers.test.cpp | 2 - docs/package.json | 10 +- 9 files changed, 5 insertions(+), 179 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp index 76c4843d4f5..f3fc6b0e5be 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp @@ -45,7 +45,6 @@ template void UltraProver_::execute_relation_chec std::vector gate_challenges(numeric::get_msb(circuit_size)); for (size_t idx = 0; idx < gate_challenges.size(); idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); - info("gate_challenges[", idx, "] = ", gate_challenges[idx]); } instance->gate_challenges = gate_challenges; sumcheck_output = sumcheck.prove(instance); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 66e4210066e..2498a690654 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -350,20 +350,6 @@ class AvmCircuitBuilder { polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; polys.incl_main_tag_err_counts[i] = rows[i].incl_main_tag_err_counts; polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; - - // TODO: check that these are calculated at circuit building time - I believe they - // are rather added at proving time, and thus can be removed - polys.perm_main_bin[i] = rows[i].perm_main_bin; - polys.perm_main_mem_a[i] = rows[i].perm_main_mem_a; - polys.perm_main_mem_b[i] = rows[i].perm_main_mem_b; - polys.perm_main_mem_c[i] = rows[i].perm_main_mem_c; - polys.perm_main_mem_ind_a[i] = rows[i].perm_main_mem_ind_a; - polys.perm_main_mem_ind_b[i] = rows[i].perm_main_mem_ind_b; - polys.perm_main_mem_ind_c[i] = rows[i].perm_main_mem_ind_c; - polys.lookup_byte_lengths[i] = rows[i].lookup_byte_lengths; - polys.lookup_byte_operations[i] = rows[i].lookup_byte_operations; - polys.incl_main_tag_err[i] = rows[i].incl_main_tag_err; - polys.incl_mem_tag_err[i] = rows[i].incl_mem_tag_err; } polys.avm_alu_u16_r0_shift = Polynomial(polys.avm_alu_u16_r0.shifted()); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp index b11475701be..d923c58c1cc 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp @@ -31,7 +31,6 @@ AvmProver AvmComposer::create_prover(CircuitConstructor& circuit_constructor) compute_witness(circuit_constructor); compute_commitment_key(circuit_constructor.get_circuit_subgroup_size()); - // TODO: check ptrs - align with other impls AvmProver output_state(proving_key, proving_key->commitment_key); return output_state; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp index 2bde94ce2fb..a2f9fe68dcf 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp @@ -60,7 +60,6 @@ class AvmComposer { void add_table_column_selector_poly_to_proving_key(bb::polynomial& small, const std::string& tag); - // TODO: probably need to move - feels like a hack void compute_commitment_key(size_t circuit_size) { proving_key->commitment_key = std::make_shared(circuit_size); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 7089601c2a3..c2c664e1b4a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -56,7 +56,6 @@ class AvmFlavor { // the unshifted and one for the shifted static constexpr size_t NUM_ALL_ENTITIES = 159; - // TODO: what for? using GrandProductRelations = std::tuple, perm_main_bin_relation, perm_main_mem_a_relation, @@ -399,153 +398,6 @@ class AvmFlavor { incl_main_tag_err_counts, incl_mem_tag_err_counts }; }; - - // TEMP: only return relevant witness wires, we do not need lookup inverses etc - RefVector get_wit_wires() - { - return { - avm_alu_alu_sel, - avm_alu_cf, - avm_alu_clk, - avm_alu_ff_tag, - avm_alu_ia, - avm_alu_ib, - avm_alu_ic, - avm_alu_in_tag, - avm_alu_op_add, - avm_alu_op_div, - avm_alu_op_eq, - avm_alu_op_eq_diff_inv, - avm_alu_op_mul, - avm_alu_op_not, - avm_alu_op_sub, - avm_alu_u128_tag, - avm_alu_u16_r0, - avm_alu_u16_r1, - avm_alu_u16_r10, - avm_alu_u16_r11, - avm_alu_u16_r12, - avm_alu_u16_r13, - avm_alu_u16_r14, - avm_alu_u16_r2, - avm_alu_u16_r3, - avm_alu_u16_r4, - avm_alu_u16_r5, - avm_alu_u16_r6, - avm_alu_u16_r7, - avm_alu_u16_r8, - avm_alu_u16_r9, - avm_alu_u16_tag, - avm_alu_u32_tag, - avm_alu_u64_r0, - avm_alu_u64_tag, - avm_alu_u8_r0, - avm_alu_u8_r1, - avm_alu_u8_tag, - avm_binary_acc_ia, - avm_binary_acc_ib, - avm_binary_acc_ic, - avm_binary_bin_sel, - avm_binary_clk, - avm_binary_ia_bytes, - avm_binary_ib_bytes, - avm_binary_ic_bytes, - avm_binary_in_tag, - avm_binary_mem_tag_ctr, - avm_binary_mem_tag_ctr_inv, - avm_binary_op_id, - avm_binary_start, - avm_byte_lookup_bin_sel, - avm_byte_lookup_table_byte_lengths, - avm_byte_lookup_table_in_tags, - avm_byte_lookup_table_input_a, - avm_byte_lookup_table_input_b, - avm_byte_lookup_table_op_id, - avm_byte_lookup_table_output, - avm_main_alu_sel, - avm_main_bin_op_id, - avm_main_bin_sel, - avm_main_ia, - avm_main_ib, - avm_main_ic, - avm_main_ind_a, - avm_main_ind_b, - avm_main_ind_c, - avm_main_ind_op_a, - avm_main_ind_op_b, - avm_main_ind_op_c, - avm_main_internal_return_ptr, - avm_main_inv, - avm_main_last, - avm_main_mem_idx_a, - avm_main_mem_idx_b, - avm_main_mem_idx_c, - avm_main_mem_op_a, - avm_main_mem_op_b, - avm_main_mem_op_c, - avm_main_op_err, - avm_main_pc, - avm_main_r_in_tag, - avm_main_rwa, - avm_main_rwb, - avm_main_rwc, - avm_main_sel_halt, - avm_main_sel_internal_call, - avm_main_sel_internal_return, - avm_main_sel_jump, - avm_main_sel_mov, - avm_main_sel_op_add, - avm_main_sel_op_and, - avm_main_sel_op_div, - avm_main_sel_op_eq, - avm_main_sel_op_mul, - avm_main_sel_op_not, - avm_main_sel_op_or, - avm_main_sel_op_sub, - avm_main_sel_op_xor, - avm_main_sel_rng_16, - avm_main_sel_rng_8, - avm_main_tag_err, - avm_main_w_in_tag, - avm_mem_addr, - avm_mem_clk, - avm_mem_ind_op_a, - avm_mem_ind_op_b, - avm_mem_ind_op_c, - avm_mem_last, - avm_mem_lastAccess, - avm_mem_one_min_inv, - avm_mem_op_a, - avm_mem_op_b, - avm_mem_op_c, - avm_mem_r_in_tag, - avm_mem_rw, - avm_mem_sel_mov, - avm_mem_sub_clk, - avm_mem_tag, - avm_mem_tag_err, - avm_mem_val, - avm_mem_w_in_tag, - // perm_main_alu, - // perm_main_bin, - // perm_main_mem_a, - // perm_main_mem_b, - // perm_main_mem_c, - // perm_main_mem_ind_a, - // perm_main_mem_ind_b, - // perm_main_mem_ind_c, - // lookup_byte_lengths, - // lookup_byte_operations, - // incl_main_tag_err, - // incl_mem_tag_err, - // lookup_byte_lengths_counts, - // lookup_byte_operations_counts, - // incl_main_tag_err_counts, - // incl_mem_tag_err_counts - }; - }; - - RefVector get_sorted_polynomials() { return {}; }; }; template class AllEntities { @@ -1192,7 +1044,6 @@ class AvmFlavor { */ using ExtendedEdges = ProverUnivariates; - // TODO: add derived entities + witness entities /** * @brief A container for the witness commitments. * diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index d456d6844a3..0bd67e09fa3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -373,8 +373,6 @@ void AvmProver::execute_log_derivative_inverse_round() */ void AvmProver::execute_relation_check_rounds() { - // TODO: check prover polynomials are set here - using Sumcheck = SumcheckProver; auto sumcheck = Sumcheck(key->circuit_size, transcript); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 882ffbec552..75b85125615 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -259,12 +259,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) // Calculate the alpha and beta challenges - log derivative inverse round auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); - auto beta_sqr = beta * beta; - auto beta_cube = beta_sqr * beta; relation_parameters.beta = beta; relation_parameters.gamma = gamm; - relation_parameters.beta_sqr = beta_sqr; - relation_parameters.beta_cube = beta_cube; // Permutations commitments.perm_main_alu = transcript->template receive_from_prover(commitment_labels.perm_main_alu); diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index b6884a49c20..05ad9ba6540 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -1,7 +1,5 @@ #include "avm_common.test.hpp" #include "barretenberg/vm/generated/avm_flavor.hpp" -#include -#include namespace tests_avm { /** diff --git a/docs/package.json b/docs/package.json index 53e11c4e588..67a53d63e89 100644 --- a/docs/package.json +++ b/docs/package.json @@ -20,10 +20,10 @@ "write-heading-ids": "docusaurus write-heading-ids" }, "dependencies": { - "@docusaurus/core": "^3.2.0", - "@docusaurus/plugin-ideal-image": "^3.2.0", - "@docusaurus/preset-classic": "^3.2.0", - "@docusaurus/theme-mermaid": "^3.2.0", + "@docusaurus/core": "^2.4.1", + "@docusaurus/plugin-ideal-image": "^2.4.1", + "@docusaurus/preset-classic": "^2.4.1", + "@docusaurus/theme-mermaid": "^2.4.1", "@mdx-js/react": "^1.6.22", "axios": "^1.4.0", "clsx": "^1.1.1", @@ -32,7 +32,7 @@ "react": "^17.0.2", "react-dom": "^17.0.2", "react-player": "^2.12.0", - "rehype-katex": "^7.0.0", + "rehype-katex": "5", "remark-math": "3" }, "devDependencies": {