From 7e4e9b9830c3beb6396ccd3110dda09d3f4e2d59 Mon Sep 17 00:00:00 2001 From: Maddiaa <47148561+Maddiaa0@users.noreply.github.com> Date: Tue, 9 Apr 2024 11:27:28 +0100 Subject: [PATCH] feat: avm logup (#5577) relevant codegen pr https://github.com/AztecProtocol/powdr/pull/54 --- .../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 | 2 +- .../barretenberg/sumcheck/sumcheck_round.hpp | 2 +- .../ultra_honk/ultra_verifier.cpp | 1 - .../vm/generated/avm_circuit_builder.hpp | 12 +- .../vm/generated/avm_composer.cpp | 2 +- .../vm/generated/avm_composer.hpp | 2 +- .../barretenberg/vm/generated/avm_flavor.hpp | 100 +++++- .../barretenberg/vm/generated/avm_prover.cpp | 320 +++++++++++++++++- .../barretenberg/vm/generated/avm_prover.hpp | 2 + .../vm/generated/avm_verifier.cpp | 28 +- .../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 | 30 +- .../barretenberg/vm/tests/helpers.test.hpp | 1 + 23 files changed, 624 insertions(+), 220 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 3e5a3461a85..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 = 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_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 2d213345427..2498a690654 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -345,17 +345,7 @@ 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.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.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; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp index a95109f38ca..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,7 @@ 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); + 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..a2f9fe68dcf 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp @@ -62,7 +62,7 @@ class AvmComposer { 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 0c2f9abe7f8..c2c664e1b4a 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" @@ -52,6 +56,19 @@ class AvmFlavor { // the unshifted and one for the shifted static constexpr size_t NUM_ALL_ENTITIES = 159; + 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, + 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, Avm_vm::avm_main, @@ -63,7 +80,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(); @@ -71,7 +92,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 = @@ -377,7 +398,6 @@ class AvmFlavor { incl_main_tag_err_counts, incl_mem_tag_err_counts }; }; - RefVector get_sorted_polynomials() { return {}; }; }; template class AllEntities { @@ -899,9 +919,56 @@ 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); + + 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); + 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); + } }; - 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); + + for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) { + commitment = proving_key.commitment_key->commit(polynomial); + } + } + }; using FoldedPolynomials = AllEntities>; @@ -923,6 +990,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 @@ -963,6 +1044,12 @@ class AvmFlavor { */ using ExtendedEdges = ProverUnivariates; + /** + * @brief A container for the witness commitments. + * + */ + using WitnessCommitments = WitnessEntities; + class CommitmentLabels : public AllEntities { private: using Base = AllEntities; @@ -1252,6 +1339,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; @@ -1260,10 +1349,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 e887045bb96..0bd67e09fa3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -56,11 +56,315 @@ 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 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); +} + +void AvmProver::execute_log_derivative_inverse_round() +{ + auto [beta, gamma] = transcript->template get_challenges("beta", "gamma"); + + relation_parameters.beta = beta; + relation_parameters.gamma = gamma; + + key->compute_logderivative_inverses(relation_parameters); + + // 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); } /** @@ -112,13 +416,9 @@ 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(); - // 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 1e15b341e17..47e2603a9ca 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(); @@ -46,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..75b85125615 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -246,6 +246,23 @@ 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); + + // Calculate the alpha and beta challenges - log derivative inverse round + auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); + relation_parameters.beta = beta; + relation_parameters.gamma = gamm; + + // 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 +277,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 +287,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); @@ -293,6 +304,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/avm_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp index e9cb034f8a8..336c22da40b 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 be42a1d5453..e250b11693e 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 c94bdf795f4..0f4c3c0691e 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 1d933c72c91..3e4e6a1a69c 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 3df1d52ac93..4bf38ce132a 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 @@ -159,7 +159,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)); } }; @@ -230,7 +230,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)); } TEST_F(AvmMemOpcodeTests, directSet) @@ -342,7 +342,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputErrorTag) compute_mov_indices(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) @@ -351,7 +351,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputValue) compute_mov_indices(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) @@ -360,7 +360,7 @@ TEST_F(AvmMemOpcodeNegativeTests, indMovWrongOutputValue) compute_mov_indices(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. @@ -387,7 +387,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 @@ -413,7 +413,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 @@ -430,7 +430,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. @@ -444,7 +444,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 ae48b0e20a2..e62e72b7da5 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 3e5efaa4efa..05ad9ba6540 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -1,4 +1,5 @@ #include "avm_common.test.hpp" +#include "barretenberg/vm/generated/avm_flavor.hpp" namespace tests_avm { /** @@ -6,25 +7,32 @@ namespace tests_avm { * * @param trace The execution trace */ -void validate_trace_proof(std::vector&& trace) +void validate_trace_check_circuit(std::vector&& trace) { auto circuit_builder = AvmCircuitBuilder(); 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); - // auto proof = prover.construct_proof(); +/** + * @brief Helper routine proving and verifying a proof based on the supplied trace + * + * @param trace The execution trace + */ +void validate_trace_proof(std::vector&& trace) +{ + auto circuit_builder = AvmCircuitBuilder(); + circuit_builder.set_trace(std::move(trace)); + EXPECT_TRUE(circuit_builder.check_circuit()); - // auto verifier = composer.create_verifier(circuit_builder); - // bool verified = verifier.verify_proof(proof); + auto composer = AvmComposer(); + auto prover = composer.create_prover(circuit_builder); + auto proof = prover.construct_proof(); - // EXPECT_TRUE(verified); + auto verifier = composer.create_verifier(circuit_builder); + bool verified = verifier.verify_proof(proof); - // if (!verified) { - // avm_trace::log_avm_trace(circuit_builder.rows, 0, 10); - // } + EXPECT_TRUE(verified); }; /** 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,