From 569c2520c0965bdf39097f454ebb0c6a0754df9a Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Mon, 4 Dec 2023 23:23:36 +0000 Subject: [PATCH 01/15] basic test skeleton in place and building --- .../verifier/merge_recursive_verifier.cpp | 20 +++ .../verifier/merge_recursive_verifier.hpp | 35 ++++ .../honk/verifier/merge_verifier.test.cpp | 151 ++++++++++++++++++ 3 files changed, 206 insertions(+) create mode 100644 barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.cpp create mode 100644 barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp create mode 100644 barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.cpp new file mode 100644 index 000000000000..d9d0eeb4bcd6 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.cpp @@ -0,0 +1,20 @@ +#include "barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp" +#include "barretenberg/commitment_schemes/zeromorph/zeromorph.hpp" +#include "barretenberg/honk/proof_system/power_polynomial.hpp" +#include "barretenberg/numeric/bitop/get_msb.hpp" +#include "barretenberg/proof_system/library/grand_product_delta.hpp" +#include "barretenberg/transcript/transcript.hpp" + +namespace proof_system::plonk::stdlib::recursion::honk { + +template +MergeRecursiveVerifier_::MergeRecursiveVerifier_(Builder* builder) + : builder(builder) +{} + +template class MergeRecursiveVerifier_>; +template class MergeRecursiveVerifier_>; +template class MergeRecursiveVerifier_>; +template class MergeRecursiveVerifier_>; + +} // namespace proof_system::plonk::stdlib::recursion::honk diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp new file mode 100644 index 000000000000..e1a026c71fe2 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp @@ -0,0 +1,35 @@ +#pragma once +#include "barretenberg/flavor/goblin_ultra.hpp" +#include "barretenberg/flavor/goblin_ultra_recursive.hpp" +#include "barretenberg/flavor/ultra.hpp" +#include "barretenberg/flavor/ultra_recursive.hpp" +#include "barretenberg/plonk/proof_system/types/proof.hpp" +#include "barretenberg/stdlib/recursion/honk/transcript/transcript.hpp" +#include "barretenberg/sumcheck/sumcheck.hpp" + +namespace proof_system::plonk::stdlib::recursion::honk { +template class MergeRecursiveVerifier_ { + public: + using FF = typename Flavor::FF; + using Commitment = typename Flavor::Commitment; + using GroupElement = typename Flavor::GroupElement; + using VerificationKey = typename Flavor::VerificationKey; + using NativeVerificationKey = typename Flavor::NativeVerificationKey; + using VerifierCommitmentKey = typename Flavor::VerifierCommitmentKey; + using Builder = typename Flavor::CircuitBuilder; + using PairingPoints = std::array; + + Builder* builder; + + explicit MergeRecursiveVerifier_(Builder* builder); +}; + +// Instance declarations for Ultra and Goblin-Ultra verifier circuits with both conventional Ultra and Goblin-Ultra +// arithmetization. +extern template class MergeRecursiveVerifier_>; +extern template class MergeRecursiveVerifier_>; +extern template class MergeRecursiveVerifier_>; +extern template class MergeRecursiveVerifier_< + proof_system::honk::flavor::GoblinUltraRecursive_>; + +} // namespace proof_system::plonk::stdlib::recursion::honk diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp new file mode 100644 index 000000000000..570433711dd5 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp @@ -0,0 +1,151 @@ +#include "barretenberg/common/test.hpp" +#include "barretenberg/flavor/ultra_recursive.hpp" +#include "barretenberg/stdlib/hash/blake3s/blake3s.hpp" +#include "barretenberg/stdlib/hash/pedersen/pedersen.hpp" +#include "barretenberg/stdlib/primitives/curves/bn254.hpp" +#include "barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp" +#include "barretenberg/ultra_honk/ultra_composer.hpp" +#include "barretenberg/ultra_honk/ultra_verifier.hpp" + +namespace proof_system::plonk::stdlib::recursion::honk { + +/** + * @brief Test suite for recursive verification of conventional Ultra Honk proofs + * @details The recursive verification circuit is arithmetized in two different ways: 1) using the conventional Ultra + * arithmetization (UltraCircuitBuilder), or 2) a Goblin-style Ultra arithmetization (GoblinUltraCircuitBuilder). + * + * @tparam Builder + */ +template class RecursiveVerifierTest : public testing::Test { + + // Define types relevant for testing + using UltraFlavor = ::proof_system::honk::flavor::Ultra; + using GoblinUltraFlavor = ::proof_system::honk::flavor::GoblinUltra; + using UltraComposer = ::proof_system::honk::UltraComposer_; + using GoblinUltraComposer = ::proof_system::honk::UltraComposer_; + + using InnerFlavor = GoblinUltraFlavor; + using InnerComposer = GoblinUltraComposer; + using InnerBuilder = typename InnerComposer::CircuitBuilder; + using InnerCurve = bn254; + using Commitment = InnerFlavor::Commitment; + using FF = InnerFlavor::FF; + + // Types for recursive verifier circuit + using RecursiveFlavor = ::proof_system::honk::flavor::UltraRecursive_; + using RecursiveMergeVerifier = MergeRecursiveVerifier_; + using OuterBuilder = BuilderType; + + // Helper for getting composer for prover/verifier of recursive (outer) circuit + template static auto get_outer_composer() + { + if constexpr (IsGoblinBuilder) { + return GoblinUltraComposer(); + } else { + return UltraComposer(); + } + } + + /** + * @brief Generate a simple test circuit with some ECC op gates and conventional arithmetic gates + * + * @param builder + */ + static void generate_test_circuit(proof_system::GoblinUltraCircuitBuilder& builder) + { + // Add some arbitrary ecc op gates + for (size_t i = 0; i < 3; ++i) { + auto point = Commitment::random_element(); + auto scalar = FF::random_element(); + builder.queue_ecc_add_accum(point); + builder.queue_ecc_mul_accum(point, scalar); + } + // queues the result of the preceding ECC + builder.queue_ecc_eq(); // should be eq and reset + + // Add some conventional gates that utilize public inputs + for (size_t i = 0; i < 10; ++i) { + FF a = FF::random_element(); + FF b = FF::random_element(); + FF c = FF::random_element(); + FF d = a + b + c; + uint32_t a_idx = builder.add_public_variable(a); + uint32_t b_idx = builder.add_variable(b); + uint32_t c_idx = builder.add_variable(c); + uint32_t d_idx = builder.add_variable(d); + + builder.create_big_add_gate({ a_idx, b_idx, c_idx, d_idx, FF(1), FF(1), FF(1), FF(-1), FF(0) }); + } + } + + public: + static void SetUpTestSuite() { barretenberg::srs::init_crs_factory("../srs_db/ignition"); } + + /** + * @brief + * + */ + static void test_recursive_merge_verification() + { + auto op_queue = std::make_shared(); + op_queue->populate_with_mock_initital_data(); + + // Create an arbitrary inner circuit + InnerBuilder inner_circuit{ op_queue }; + generate_test_circuit(inner_circuit); + + // // Generate a proof over the inner circuit + // InnerComposer inner_composer; + // auto instance = inner_composer.create_instance(inner_circuit); + // auto inner_prover = inner_composer.create_prover(instance); + // auto inner_proof = inner_prover.construct_proof(); + + // Create a recursive verification circuit for the proof of the inner circuit + OuterBuilder outer_circuit; + RecursiveMergeVerifier verifier{ &outer_circuit }; + // auto pairing_points = verifier.verify_proof(inner_proof); + + // // Check for a failure flag in the recursive verifier circuit + // EXPECT_EQ(outer_circuit.failed(), false) << outer_circuit.err(); + + // // Check 1: Perform native verification then perform the pairing on the outputs of the recursive + // // verifier and check that the result agrees. + // auto native_verifier = inner_composer.create_verifier(instance); + // auto native_result = native_verifier.verify_proof(inner_proof); + // auto recursive_result = native_verifier.pcs_verification_key->pairing_check(pairing_points[0].get_value(), + // pairing_points[1].get_value()); + // EXPECT_EQ(recursive_result, native_result); + + // // Check 2: Ensure that the underlying native and recursive verification algorithms agree by ensuring + // // the manifests produced by each agree. + // auto recursive_manifest = verifier.transcript->get_manifest(); + // auto native_manifest = native_verifier.transcript->get_manifest(); + // for (size_t i = 0; i < recursive_manifest.size(); ++i) { + // EXPECT_EQ(recursive_manifest[i], native_manifest[i]); + // } + + // // Check 3: Construct and verify a proof of the recursive verifier circuit + // { + // auto composer = get_outer_composer(); + // auto instance = composer.create_instance(outer_circuit); + // auto prover = composer.create_prover(instance); + // auto verifier = composer.create_verifier(instance); + // auto proof = prover.construct_proof(); + // bool verified = verifier.verify_proof(proof); + + // ASSERT(verified); + // } + } +}; + +// Run the recursive verifier tests with conventional Ultra builder and Goblin builder +using BuilderTypes = testing::Types; + +TYPED_TEST_SUITE(RecursiveVerifierTest, BuilderTypes); + +HEAVY_TYPED_TEST(RecursiveVerifierTest, SingleRecursiveVerification) +{ + TestFixture::test_recursive_merge_verification(); +}; + +} // namespace proof_system::plonk::stdlib::recursion::honk \ No newline at end of file From e2534a23ab84c8e3e910ae2fd63d9e3b7f21a36b Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Mon, 4 Dec 2023 23:39:05 +0000 Subject: [PATCH 02/15] test native verification of sample circuit merge --- .../honk/verifier/merge_verifier.test.cpp | 42 ++++++++++++++++--- 1 file changed, 36 insertions(+), 6 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp index 570433711dd5..0186cdbb219a 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp @@ -16,7 +16,7 @@ namespace proof_system::plonk::stdlib::recursion::honk { * * @tparam Builder */ -template class RecursiveVerifierTest : public testing::Test { +template class RecursiveMergeVerifierTest : public testing::Test { // Define types relevant for testing using UltraFlavor = ::proof_system::honk::flavor::Ultra; @@ -51,8 +51,11 @@ template class RecursiveVerifierTest : public testing::Te * * @param builder */ - static void generate_test_circuit(proof_system::GoblinUltraCircuitBuilder& builder) + static proof_system::GoblinUltraCircuitBuilder generate_sample_circuit(const std::shared_ptr& op_queue) { + // Create an arbitrary inner circuit + InnerBuilder builder{ op_queue }; + // Add some arbitrary ecc op gates for (size_t i = 0; i < 3; ++i) { auto point = Commitment::random_element(); @@ -76,11 +79,34 @@ template class RecursiveVerifierTest : public testing::Te builder.create_big_add_gate({ a_idx, b_idx, c_idx, d_idx, FF(1), FF(1), FF(1), FF(-1), FF(0) }); } + + return builder; } public: static void SetUpTestSuite() { barretenberg::srs::init_crs_factory("../srs_db/ignition"); } + static void test_sample_circuit_merge() + { + auto op_queue = std::make_shared(); + + // Populate op queue with mock initial data since we don't handle the empty previous aggregate transcript case + op_queue->populate_with_mock_initital_data(); + + // Create an arbitrary inner circuit with goblin ECC op gates + InnerBuilder sample_circuit = generate_sample_circuit(op_queue); + + // Generate a merge proof for the inner circuit + InnerComposer composer; + + // Construct and natively verify the merge proof + auto merge_prover = composer.create_merge_prover(op_queue); + auto merge_verifier = composer.create_merge_verifier(0); + auto merge_proof = merge_prover.construct_proof(); + bool verified = merge_verifier.verify_proof(merge_proof); + EXPECT_TRUE(verified); + } + /** * @brief * @@ -91,8 +117,7 @@ template class RecursiveVerifierTest : public testing::Te op_queue->populate_with_mock_initital_data(); // Create an arbitrary inner circuit - InnerBuilder inner_circuit{ op_queue }; - generate_test_circuit(inner_circuit); + InnerBuilder inner_circuit = generate_sample_circuit(op_queue); // // Generate a proof over the inner circuit // InnerComposer inner_composer; @@ -141,9 +166,14 @@ template class RecursiveVerifierTest : public testing::Te // Run the recursive verifier tests with conventional Ultra builder and Goblin builder using BuilderTypes = testing::Types; -TYPED_TEST_SUITE(RecursiveVerifierTest, BuilderTypes); +TYPED_TEST_SUITE(RecursiveMergeVerifierTest, BuilderTypes); + +HEAVY_TYPED_TEST(RecursiveMergeVerifierTest, NativeSampleCircuitMerge) +{ + TestFixture::test_sample_circuit_merge(); +}; -HEAVY_TYPED_TEST(RecursiveVerifierTest, SingleRecursiveVerification) +HEAVY_TYPED_TEST(RecursiveMergeVerifierTest, SingleRecursiveVerification) { TestFixture::test_recursive_merge_verification(); }; From df3ced521c8e28ef958af4925023d0dd550c629d Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Tue, 5 Dec 2023 22:17:46 +0000 Subject: [PATCH 03/15] tests pass with goblin arith --- .../commitment_schemes/kzg/kzg.hpp | 11 +- .../verifier/merge_recursive_verifier.cpp | 93 ++++++++++++--- .../verifier/merge_recursive_verifier.hpp | 44 ++++--- .../honk/verifier/merge_verifier.test.cpp | 108 ++++++++++-------- 4 files changed, 163 insertions(+), 93 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/commitment_schemes/kzg/kzg.hpp b/barretenberg/cpp/src/barretenberg/commitment_schemes/kzg/kzg.hpp index e0cfc6e6477a..926923d767e3 100644 --- a/barretenberg/cpp/src/barretenberg/commitment_schemes/kzg/kzg.hpp +++ b/barretenberg/cpp/src/barretenberg/commitment_schemes/kzg/kzg.hpp @@ -81,16 +81,15 @@ template class KZG { auto quotient_commitment = verifier_transcript->template receive_from_prover("KZG:W"); GroupElement P_0; - // Note: In the recursive setting, we only add the contribution if it is not the point at infinity (i.e. if the - // evaluation is not equal to zero). if constexpr (Curve::is_stdlib_type) { auto builder = verifier_transcript->builder; auto one = Fr(builder, 1); - std::vector commitments = { claim.commitment, quotient_commitment }; - std::vector scalars = { one, claim.opening_pair.challenge }; + std::vector commitments = { claim.commitment, + quotient_commitment, + GroupElement::one(builder) }; + std::vector scalars = { one, claim.opening_pair.challenge, -claim.opening_pair.evaluation }; P_0 = GroupElement::batch_mul(commitments, scalars); - // Note: This implementation assumes the evaluation is zero (as is the case for shplonk). - ASSERT(claim.opening_pair.evaluation.get_value() == 0); + } else { P_0 = claim.commitment; P_0 += quotient_commitment * claim.opening_pair.challenge; diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.cpp index d9d0eeb4bcd6..f04c32c95834 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.cpp @@ -1,20 +1,87 @@ #include "barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp" -#include "barretenberg/commitment_schemes/zeromorph/zeromorph.hpp" -#include "barretenberg/honk/proof_system/power_polynomial.hpp" -#include "barretenberg/numeric/bitop/get_msb.hpp" -#include "barretenberg/proof_system/library/grand_product_delta.hpp" -#include "barretenberg/transcript/transcript.hpp" -namespace proof_system::plonk::stdlib::recursion::honk { +namespace proof_system::plonk::stdlib::recursion::goblin { -template -MergeRecursiveVerifier_::MergeRecursiveVerifier_(Builder* builder) +template +MergeRecursiveVerifier_::MergeRecursiveVerifier_(CircuitBuilder* builder) : builder(builder) {} -template class MergeRecursiveVerifier_>; -template class MergeRecursiveVerifier_>; -template class MergeRecursiveVerifier_>; -template class MergeRecursiveVerifier_>; +/** + * @brief Construct recursive verifier for Goblin Merge protocol, up to but not including the pairing + * + * @tparam Flavor + * @param proof + * @return std::array Inputs to final pairing + */ +template +std::array::Element, 2> MergeRecursiveVerifier_::verify_proof( + const plonk::proof& proof) +{ + transcript = std::make_shared(builder, proof.proof_data); -} // namespace proof_system::plonk::stdlib::recursion::honk + // Receive commitments [t_i^{shift}], [T_{i-1}], and [T_i] + std::array C_T_prev; + std::array C_t_shift; + std::array C_T_current; + for (size_t idx = 0; idx < NUM_WIRES; ++idx) { + C_T_prev[idx] = transcript->template receive_from_prover("T_PREV_" + std::to_string(idx + 1)); + C_t_shift[idx] = transcript->template receive_from_prover("t_SHIFT_" + std::to_string(idx + 1)); + C_T_current[idx] = transcript->template receive_from_prover("T_CURRENT_" + std::to_string(idx + 1)); + } + + FF kappa = transcript->get_challenge("kappa"); + + // Receive transcript poly evaluations and add corresponding univariate opening claims {(\kappa, p(\kappa), [p(X)]} + std::array T_prev_evals; + std::array t_shift_evals; + std::array T_current_evals; + std::vector opening_claims; + for (size_t idx = 0; idx < NUM_WIRES; ++idx) { + T_prev_evals[idx] = transcript->template receive_from_prover("T_prev_eval_" + std::to_string(idx + 1)); + opening_claims.emplace_back(OpeningClaim{ { kappa, T_prev_evals[idx] }, C_T_prev[idx] }); + } + for (size_t idx = 0; idx < NUM_WIRES; ++idx) { + t_shift_evals[idx] = transcript->template receive_from_prover("t_shift_eval_" + std::to_string(idx + 1)); + opening_claims.emplace_back(OpeningClaim{ { kappa, t_shift_evals[idx] }, C_t_shift[idx] }); + } + for (size_t idx = 0; idx < NUM_WIRES; ++idx) { + T_current_evals[idx] = + transcript->template receive_from_prover("T_current_eval_" + std::to_string(idx + 1)); + opening_claims.emplace_back(OpeningClaim{ { kappa, T_current_evals[idx] }, C_T_current[idx] }); + } + + // Check the identity T_i(\kappa) = T_{i-1}(\kappa) + t_i^{shift}(\kappa) + for (size_t idx = 0; idx < NUM_WIRES; ++idx) { + T_current_evals[idx].assert_equal(T_prev_evals[idx] + t_shift_evals[idx]); + } + + FF alpha = transcript->get_challenge("alpha"); + + // Constuct batched commitment and batched evaluation from constituents using batching challenge \alpha + std::vector scalars; + std::vector commitments; + scalars.emplace_back(FF(builder, 1)); + commitments.emplace_back(opening_claims[0].commitment); + auto batched_eval = opening_claims[0].opening_pair.evaluation; + auto alpha_pow = alpha; + for (size_t idx = 1; idx < opening_claims.size(); ++idx) { + auto& claim = opening_claims[idx]; + scalars.emplace_back(alpha_pow); + commitments.emplace_back(claim.commitment); + batched_eval += alpha_pow * claim.opening_pair.evaluation; + alpha_pow *= alpha; + } + + auto batched_commitment = Commitment::batch_mul(commitments, scalars); + + OpeningClaim batched_claim = { { kappa, batched_eval }, batched_commitment }; + + auto pairing_points = KZG::compute_pairing_points(batched_claim, transcript); + + return pairing_points; +} + +template class MergeRecursiveVerifier_; + +} // namespace proof_system::plonk::stdlib::recursion::goblin diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp index e1a026c71fe2..341d91a1bd16 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp @@ -1,35 +1,31 @@ #pragma once -#include "barretenberg/flavor/goblin_ultra.hpp" -#include "barretenberg/flavor/goblin_ultra_recursive.hpp" -#include "barretenberg/flavor/ultra.hpp" -#include "barretenberg/flavor/ultra_recursive.hpp" +#include "barretenberg/commitment_schemes/kzg/kzg.hpp" #include "barretenberg/plonk/proof_system/types/proof.hpp" +#include "barretenberg/stdlib/primitives/curves/bn254.hpp" #include "barretenberg/stdlib/recursion/honk/transcript/transcript.hpp" -#include "barretenberg/sumcheck/sumcheck.hpp" -namespace proof_system::plonk::stdlib::recursion::honk { -template class MergeRecursiveVerifier_ { +namespace proof_system::plonk::stdlib::recursion::goblin { +template class MergeRecursiveVerifier_ { public: - using FF = typename Flavor::FF; - using Commitment = typename Flavor::Commitment; - using GroupElement = typename Flavor::GroupElement; - using VerificationKey = typename Flavor::VerificationKey; - using NativeVerificationKey = typename Flavor::NativeVerificationKey; - using VerifierCommitmentKey = typename Flavor::VerifierCommitmentKey; - using Builder = typename Flavor::CircuitBuilder; + using Curve = bn254; + using FF = typename Curve::ScalarField; + using Commitment = typename Curve::Element; + using GroupElement = typename Curve::Element; + using KZG = ::proof_system::honk::pcs::kzg::KZG; + using OpeningClaim = ::proof_system::honk::pcs::OpeningClaim; using PairingPoints = std::array; + using Transcript = honk::Transcript; - Builder* builder; + CircuitBuilder* builder; + std::shared_ptr transcript; - explicit MergeRecursiveVerifier_(Builder* builder); + static constexpr size_t NUM_WIRES = arithmetization::UltraHonk::NUM_WIRES; + + explicit MergeRecursiveVerifier_(CircuitBuilder* builder); + + PairingPoints verify_proof(const plonk::proof& proof); }; -// Instance declarations for Ultra and Goblin-Ultra verifier circuits with both conventional Ultra and Goblin-Ultra -// arithmetization. -extern template class MergeRecursiveVerifier_>; -extern template class MergeRecursiveVerifier_>; -extern template class MergeRecursiveVerifier_>; -extern template class MergeRecursiveVerifier_< - proof_system::honk::flavor::GoblinUltraRecursive_>; +extern template class MergeRecursiveVerifier_; -} // namespace proof_system::plonk::stdlib::recursion::honk +} // namespace proof_system::plonk::stdlib::recursion::goblin diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp index 0186cdbb219a..c1ca16063574 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp @@ -1,18 +1,18 @@ #include "barretenberg/common/test.hpp" -#include "barretenberg/flavor/ultra_recursive.hpp" -#include "barretenberg/stdlib/hash/blake3s/blake3s.hpp" -#include "barretenberg/stdlib/hash/pedersen/pedersen.hpp" +// #include "barretenberg/flavor/ultra_recursive.hpp" +// #include "barretenberg/stdlib/hash/blake3s/blake3s.hpp" +// #include "barretenberg/stdlib/hash/pedersen/pedersen.hpp" #include "barretenberg/stdlib/primitives/curves/bn254.hpp" #include "barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" #include "barretenberg/ultra_honk/ultra_verifier.hpp" -namespace proof_system::plonk::stdlib::recursion::honk { +namespace proof_system::plonk::stdlib::recursion::goblin { /** - * @brief Test suite for recursive verification of conventional Ultra Honk proofs - * @details The recursive verification circuit is arithmetized in two different ways: 1) using the conventional Ultra - * arithmetization (UltraCircuitBuilder), or 2) a Goblin-style Ultra arithmetization (GoblinUltraCircuitBuilder). + * @brief Test suite for recursive verification of Goblin Merge proofs + * @details The recursive verification circuit is arithmetized using Goblin-style Ultra arithmetization + * (GoblinUltraCircuitBuilder). * * @tparam Builder */ @@ -23,6 +23,7 @@ template class RecursiveMergeVerifierTest : public testin using GoblinUltraFlavor = ::proof_system::honk::flavor::GoblinUltra; using UltraComposer = ::proof_system::honk::UltraComposer_; using GoblinUltraComposer = ::proof_system::honk::UltraComposer_; + using VerifierCommitmentKey = ::proof_system::honk::pcs::VerifierCommitmentKey; using InnerFlavor = GoblinUltraFlavor; using InnerComposer = GoblinUltraComposer; @@ -32,8 +33,7 @@ template class RecursiveMergeVerifierTest : public testin using FF = InnerFlavor::FF; // Types for recursive verifier circuit - using RecursiveFlavor = ::proof_system::honk::flavor::UltraRecursive_; - using RecursiveMergeVerifier = MergeRecursiveVerifier_; + using RecursiveMergeVerifier = MergeRecursiveVerifier_; using OuterBuilder = BuilderType; // Helper for getting composer for prover/verifier of recursive (outer) circuit @@ -86,6 +86,10 @@ template class RecursiveMergeVerifierTest : public testin public: static void SetUpTestSuite() { barretenberg::srs::init_crs_factory("../srs_db/ignition"); } + /** + * @brief Test native merge proof construction/verification for the sample circuit + * + */ static void test_sample_circuit_merge() { auto op_queue = std::make_shared(); @@ -108,8 +112,10 @@ template class RecursiveMergeVerifierTest : public testin } /** - * @brief - * + * @brief Test recursive merge verification for the ops generated by a sample circuit + * @details We construct and verify an Ultra Honk proof of the recursive merge verifier circuit to check its + * correctness rather than calling check_circuit since this functionality is incomplete for the Goblin + * arithmetization */ static void test_recursive_merge_verification() { @@ -119,52 +125,54 @@ template class RecursiveMergeVerifierTest : public testin // Create an arbitrary inner circuit InnerBuilder inner_circuit = generate_sample_circuit(op_queue); - // // Generate a proof over the inner circuit - // InnerComposer inner_composer; - // auto instance = inner_composer.create_instance(inner_circuit); - // auto inner_prover = inner_composer.create_prover(instance); - // auto inner_proof = inner_prover.construct_proof(); + // Generate a proof over the inner circuit + InnerComposer inner_composer; + auto merge_prover = inner_composer.create_merge_prover(op_queue); + auto merge_proof = merge_prover.construct_proof(); // Create a recursive verification circuit for the proof of the inner circuit OuterBuilder outer_circuit; RecursiveMergeVerifier verifier{ &outer_circuit }; - // auto pairing_points = verifier.verify_proof(inner_proof); - - // // Check for a failure flag in the recursive verifier circuit - // EXPECT_EQ(outer_circuit.failed(), false) << outer_circuit.err(); - - // // Check 1: Perform native verification then perform the pairing on the outputs of the recursive - // // verifier and check that the result agrees. - // auto native_verifier = inner_composer.create_verifier(instance); - // auto native_result = native_verifier.verify_proof(inner_proof); - // auto recursive_result = native_verifier.pcs_verification_key->pairing_check(pairing_points[0].get_value(), - // pairing_points[1].get_value()); - // EXPECT_EQ(recursive_result, native_result); - - // // Check 2: Ensure that the underlying native and recursive verification algorithms agree by ensuring - // // the manifests produced by each agree. - // auto recursive_manifest = verifier.transcript->get_manifest(); - // auto native_manifest = native_verifier.transcript->get_manifest(); - // for (size_t i = 0; i < recursive_manifest.size(); ++i) { - // EXPECT_EQ(recursive_manifest[i], native_manifest[i]); - // } - - // // Check 3: Construct and verify a proof of the recursive verifier circuit - // { - // auto composer = get_outer_composer(); - // auto instance = composer.create_instance(outer_circuit); - // auto prover = composer.create_prover(instance); - // auto verifier = composer.create_verifier(instance); - // auto proof = prover.construct_proof(); - // bool verified = verifier.verify_proof(proof); - - // ASSERT(verified); - // } + auto pairing_points = verifier.verify_proof(merge_proof); + + // Check for a failure flag in the recursive verifier circuit + EXPECT_EQ(outer_circuit.failed(), false) << outer_circuit.err(); + + // Check 1: Perform native merge verification then perform the pairing on the outputs of the recursive merge + // verifier and check that the result agrees. + auto native_verifier = inner_composer.create_merge_verifier(0); + bool verified_native = native_verifier.verify_proof(merge_proof); + VerifierCommitmentKey pcs_verification_key(0, srs::get_crs_factory()); + auto verified_recursive = + pcs_verification_key.pairing_check(pairing_points[0].get_value(), pairing_points[1].get_value()); + EXPECT_EQ(verified_native, verified_recursive); + EXPECT_TRUE(verified_recursive); + + // Check 2: Ensure that the underlying native and recursive verification algorithms agree by ensuring + // the manifests produced by each agree. + auto recursive_manifest = verifier.transcript->get_manifest(); + auto native_manifest = native_verifier.transcript->get_manifest(); + for (size_t i = 0; i < recursive_manifest.size(); ++i) { + EXPECT_EQ(recursive_manifest[i], native_manifest[i]); + } + + // Check 3: Construct and verify a (goblin) ultra honk proof of the Merge recursive verifier circuit + { + auto composer = get_outer_composer(); + auto instance = composer.create_instance(outer_circuit); + auto prover = composer.create_prover(instance); + auto verifier = composer.create_verifier(instance); + auto proof = prover.construct_proof(); + bool verified = verifier.verify_proof(proof); + + EXPECT_TRUE(verified); + } } }; // Run the recursive verifier tests with conventional Ultra builder and Goblin builder -using BuilderTypes = testing::Types; +// using BuilderTypes = testing::Types; +using BuilderTypes = testing::Types; TYPED_TEST_SUITE(RecursiveMergeVerifierTest, BuilderTypes); @@ -178,4 +186,4 @@ HEAVY_TYPED_TEST(RecursiveMergeVerifierTest, SingleRecursiveVerification) TestFixture::test_recursive_merge_verification(); }; -} // namespace proof_system::plonk::stdlib::recursion::honk \ No newline at end of file +} // namespace proof_system::plonk::stdlib::recursion::goblin \ No newline at end of file From 658bafd21fd8ab5e0ca93e1ec1e1045b662e597a Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Wed, 6 Dec 2023 17:52:57 +0000 Subject: [PATCH 04/15] remove template and simplify rec merge test --- .../honk/verifier/merge_verifier.test.cpp | 60 ++++++------------- 1 file changed, 18 insertions(+), 42 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp index c1ca16063574..f7c129d232a4 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp @@ -1,11 +1,7 @@ #include "barretenberg/common/test.hpp" -// #include "barretenberg/flavor/ultra_recursive.hpp" -// #include "barretenberg/stdlib/hash/blake3s/blake3s.hpp" -// #include "barretenberg/stdlib/hash/pedersen/pedersen.hpp" #include "barretenberg/stdlib/primitives/curves/bn254.hpp" #include "barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" -#include "barretenberg/ultra_honk/ultra_verifier.hpp" namespace proof_system::plonk::stdlib::recursion::goblin { @@ -16,35 +12,23 @@ namespace proof_system::plonk::stdlib::recursion::goblin { * * @tparam Builder */ -template class RecursiveMergeVerifierTest : public testing::Test { +class RecursiveMergeVerifierTest : public testing::Test { - // Define types relevant for testing - using UltraFlavor = ::proof_system::honk::flavor::Ultra; + // Types for recursive verifier circuit + using RecursiveBuilder = GoblinUltraCircuitBuilder; + using RecursiveMergeVerifier = MergeRecursiveVerifier_; + + // Define types relevant for inner circuit using GoblinUltraFlavor = ::proof_system::honk::flavor::GoblinUltra; - using UltraComposer = ::proof_system::honk::UltraComposer_; using GoblinUltraComposer = ::proof_system::honk::UltraComposer_; - using VerifierCommitmentKey = ::proof_system::honk::pcs::VerifierCommitmentKey; - using InnerFlavor = GoblinUltraFlavor; using InnerComposer = GoblinUltraComposer; using InnerBuilder = typename InnerComposer::CircuitBuilder; - using InnerCurve = bn254; + + // Define additional types for testing purposes using Commitment = InnerFlavor::Commitment; using FF = InnerFlavor::FF; - - // Types for recursive verifier circuit - using RecursiveMergeVerifier = MergeRecursiveVerifier_; - using OuterBuilder = BuilderType; - - // Helper for getting composer for prover/verifier of recursive (outer) circuit - template static auto get_outer_composer() - { - if constexpr (IsGoblinBuilder) { - return GoblinUltraComposer(); - } else { - return UltraComposer(); - } - } + using VerifierCommitmentKey = ::proof_system::honk::pcs::VerifierCommitmentKey; /** * @brief Generate a simple test circuit with some ECC op gates and conventional arithmetic gates @@ -100,10 +84,8 @@ template class RecursiveMergeVerifierTest : public testin // Create an arbitrary inner circuit with goblin ECC op gates InnerBuilder sample_circuit = generate_sample_circuit(op_queue); - // Generate a merge proof for the inner circuit - InnerComposer composer; - // Construct and natively verify the merge proof + InnerComposer composer; auto merge_prover = composer.create_merge_prover(op_queue); auto merge_verifier = composer.create_merge_verifier(0); auto merge_proof = merge_prover.construct_proof(); @@ -130,8 +112,8 @@ template class RecursiveMergeVerifierTest : public testin auto merge_prover = inner_composer.create_merge_prover(op_queue); auto merge_proof = merge_prover.construct_proof(); - // Create a recursive verification circuit for the proof of the inner circuit - OuterBuilder outer_circuit; + // Create a recursive merge verification circuit for the merge proof + RecursiveBuilder outer_circuit; RecursiveMergeVerifier verifier{ &outer_circuit }; auto pairing_points = verifier.verify_proof(merge_proof); @@ -148,7 +130,7 @@ template class RecursiveMergeVerifierTest : public testin EXPECT_EQ(verified_native, verified_recursive); EXPECT_TRUE(verified_recursive); - // Check 2: Ensure that the underlying native and recursive verification algorithms agree by ensuring + // Check 2: Ensure that the underlying native and recursive merge verification algorithms agree by ensuring // the manifests produced by each agree. auto recursive_manifest = verifier.transcript->get_manifest(); auto native_manifest = native_verifier.transcript->get_manifest(); @@ -158,7 +140,7 @@ template class RecursiveMergeVerifierTest : public testin // Check 3: Construct and verify a (goblin) ultra honk proof of the Merge recursive verifier circuit { - auto composer = get_outer_composer(); + GoblinUltraComposer composer; auto instance = composer.create_instance(outer_circuit); auto prover = composer.create_prover(instance); auto verifier = composer.create_verifier(instance); @@ -170,20 +152,14 @@ template class RecursiveMergeVerifierTest : public testin } }; -// Run the recursive verifier tests with conventional Ultra builder and Goblin builder -// using BuilderTypes = testing::Types; -using BuilderTypes = testing::Types; - -TYPED_TEST_SUITE(RecursiveMergeVerifierTest, BuilderTypes); - -HEAVY_TYPED_TEST(RecursiveMergeVerifierTest, NativeSampleCircuitMerge) +TEST_F(RecursiveMergeVerifierTest, NativeSampleCircuitMerge) { - TestFixture::test_sample_circuit_merge(); + RecursiveMergeVerifierTest::test_sample_circuit_merge(); }; -HEAVY_TYPED_TEST(RecursiveMergeVerifierTest, SingleRecursiveVerification) +TEST_F(RecursiveMergeVerifierTest, SingleRecursiveVerification) { - TestFixture::test_recursive_merge_verification(); + RecursiveMergeVerifierTest::test_recursive_merge_verification(); }; } // namespace proof_system::plonk::stdlib::recursion::goblin \ No newline at end of file From 9449e6c2ba220c4c056062bbd2994341d4bfc3a9 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Wed, 6 Dec 2023 18:27:06 +0000 Subject: [PATCH 05/15] basic stuctures in place; linker issue --- .../cpp/src/barretenberg/goblin/goblin.hpp | 22 ++++++++++++++----- .../goblin/full_goblin_recursion.test.cpp | 20 ++++++++++++++--- 2 files changed, 34 insertions(+), 8 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp index 315b66657f3e..fb941c0f83eb 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp +++ b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp @@ -4,6 +4,7 @@ #include "barretenberg/proof_system/circuit_builder/eccvm/eccvm_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/goblin_translator_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp" +#include "barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp" #include "barretenberg/translator_vm/goblin_translator_composer.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" @@ -41,8 +42,11 @@ class Goblin { using ECCVMComposer = proof_system::honk::ECCVMComposer; using TranslatorBuilder = proof_system::GoblinTranslatorCircuitBuilder; using TranslatorComposer = proof_system::honk::GoblinTranslatorComposer; + using RecursiveMergeVerifier = + proof_system::plonk::stdlib::recursion::goblin::MergeRecursiveVerifier_; std::shared_ptr op_queue = std::make_shared(); + HonkProof merge_proof; private: // TODO(https://github.com/AztecProtocol/barretenberg/issues/798) unique_ptr use is a hack @@ -57,18 +61,26 @@ class Goblin { * * @param circuit_builder */ - AccumulationOutput accumulate(GoblinUltraCircuitBuilder& circuit_builder) + AccumulationOutput accumulate(GoblinUltraCircuitBuilder& circuit_builder, bool verify_merge = true) { - // TODO(https://github.com/AztecProtocol/barretenberg/issues/797) Complete the "kernel" logic by recursively - // verifying previous merge proof - + // Complete the circuit logic by recursively verifying previous merge proof + // Note: the first time we call accumulate there is no merge proof to recursively verify. This is related to + // issue (https://github.com/AztecProtocol/barretenberg/issues/723) + if (verify_merge) { + RecursiveMergeVerifier merge_verifier{ &circuit_builder }; + // Recursively verify the merge proof constructed on the previous call to accumulate + [[maybe_unused]] auto pairing_points = merge_verifier.verify_proof(merge_proof); + } + + // Construct a Honk proof for the main circuit GoblinUltraComposer composer; auto instance = composer.create_instance(circuit_builder); auto prover = composer.create_prover(instance); auto ultra_proof = prover.construct_proof(); + // Construct and store the merge proof to be recursively verified on the next call to accumulate auto merge_prover = composer.create_merge_prover(op_queue); - [[maybe_unused]] auto merge_proof = merge_prover.construct_proof(); + merge_proof = merge_prover.construct_proof(); return { ultra_proof, instance->verification_key }; }; diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp index 51d9f1943cbd..f21c21b92e1f 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp @@ -58,8 +58,11 @@ class GoblinRecursionTests : public ::testing::Test { // Execute recursive aggregation of previous kernel proof RecursiveVerifier verifier{ &builder, kernel_input.verification_key }; // TODO(https://github.com/AztecProtocol/barretenberg/issues/801): Aggregation - auto pairing_points = verifier.verify_proof(kernel_input.proof); // app function proof - pairing_points = verifier.verify_proof(kernel_input.proof); // previous kernel proof + auto pairing_points = verifier.verify_proof(kernel_input.proof); // previous kernel proof + // TODO(https://github.com/AztecProtocol/barretenberg/issues/803): Mock app circuit. In the absence of a mocked + // app circuit proof, we simply perform another recursive verification for the previous kernel proof to + // approximate the work done for the app proof. + pairing_points = verifier.verify_proof(kernel_input.proof); // app function proof } }; @@ -74,7 +77,18 @@ TEST_F(GoblinRecursionTests, Pseudo) // Construct an initial circuit; its proof will be recursively verified by the first kernel GoblinUltraBuilder initial_circuit{ goblin.op_queue }; GoblinTestingUtils::construct_simple_initial_circuit(initial_circuit); - KernelInput kernel_input = goblin.accumulate(initial_circuit); + + // GoblinUltraComposer composer; + // auto instance = composer.create_instance(initial_circuit); + // auto prover = composer.create_prover(instance); + // auto ultra_proof = prover.construct_proof(); + + // auto merge_prover = composer.create_merge_prover(goblin.op_queue); + // auto merge_proof = merge_prover.construct_proof(); + + // KernelInput kernel_input = { ultra_proof, instance->verification_key }; + + KernelInput kernel_input = goblin.accumulate(initial_circuit, /*verify_merge=*/false); // Construct a series of simple Goblin circuits; generate and verify their proofs size_t NUM_CIRCUITS = 2; From d04f847a8191feaacadc0cb4ba1982aac4667ff3 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Wed, 6 Dec 2023 21:04:39 +0000 Subject: [PATCH 06/15] move gob to stdlib; test passes w merge rec ver --- barretenberg/cpp/src/CMakeLists.txt | 1 - .../src/barretenberg/eccvm/eccvm_prover.hpp | 2 +- .../src/barretenberg/goblin/CMakeLists.txt | 1 - .../goblin/full_goblin_composer.test.cpp | 67 ------------------- .../goblin/full_goblin_recursion.test.cpp | 11 +-- .../{ => stdlib/recursion}/goblin/goblin.hpp | 5 +- .../recursion}/goblin/mock_circuits.hpp | 3 +- .../goblin_translator_verifier.hpp | 2 +- .../translation_evaluations.hpp | 0 9 files changed, 11 insertions(+), 81 deletions(-) delete mode 100644 barretenberg/cpp/src/barretenberg/goblin/CMakeLists.txt delete mode 100644 barretenberg/cpp/src/barretenberg/goblin/full_goblin_composer.test.cpp rename barretenberg/cpp/src/barretenberg/{ => stdlib/recursion}/goblin/goblin.hpp (97%) rename barretenberg/cpp/src/barretenberg/{ => stdlib/recursion}/goblin/mock_circuits.hpp (97%) rename barretenberg/cpp/src/barretenberg/{goblin => translator_vm}/translation_evaluations.hpp (100%) diff --git a/barretenberg/cpp/src/CMakeLists.txt b/barretenberg/cpp/src/CMakeLists.txt index b09a2181ebca..b5368f0ee948 100644 --- a/barretenberg/cpp/src/CMakeLists.txt +++ b/barretenberg/cpp/src/CMakeLists.txt @@ -59,7 +59,6 @@ add_subdirectory(barretenberg/env) add_subdirectory(barretenberg/examples) add_subdirectory(barretenberg/flavor) add_subdirectory(barretenberg/grumpkin_srs_gen) -add_subdirectory(barretenberg/goblin) add_subdirectory(barretenberg/honk) add_subdirectory(barretenberg/join_split_example) add_subdirectory(barretenberg/numeric) diff --git a/barretenberg/cpp/src/barretenberg/eccvm/eccvm_prover.hpp b/barretenberg/cpp/src/barretenberg/eccvm/eccvm_prover.hpp index af6f4ec457f6..3881b4e9d69d 100644 --- a/barretenberg/cpp/src/barretenberg/eccvm/eccvm_prover.hpp +++ b/barretenberg/cpp/src/barretenberg/eccvm/eccvm_prover.hpp @@ -2,11 +2,11 @@ #include "barretenberg/commitment_schemes/gemini/gemini.hpp" #include "barretenberg/commitment_schemes/shplonk/shplonk.hpp" #include "barretenberg/flavor/ecc_vm.hpp" -#include "barretenberg/goblin/translation_evaluations.hpp" #include "barretenberg/plonk/proof_system/types/proof.hpp" #include "barretenberg/relations/relation_parameters.hpp" #include "barretenberg/sumcheck/sumcheck_output.hpp" #include "barretenberg/transcript/transcript.hpp" +#include "barretenberg/translator_vm/translation_evaluations.hpp" namespace proof_system::honk { diff --git a/barretenberg/cpp/src/barretenberg/goblin/CMakeLists.txt b/barretenberg/cpp/src/barretenberg/goblin/CMakeLists.txt deleted file mode 100644 index a6c3c61383a6..000000000000 --- a/barretenberg/cpp/src/barretenberg/goblin/CMakeLists.txt +++ /dev/null @@ -1 +0,0 @@ -barretenberg_module(goblin ultra_honk eccvm translator_vm transcript) \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_composer.test.cpp b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_composer.test.cpp deleted file mode 100644 index 7503307881ab..000000000000 --- a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_composer.test.cpp +++ /dev/null @@ -1,67 +0,0 @@ -#include "barretenberg/eccvm/eccvm_composer.hpp" -#include "barretenberg/goblin/goblin.hpp" -#include "barretenberg/goblin/mock_circuits.hpp" -#include "barretenberg/goblin/translation_evaluations.hpp" -#include "barretenberg/proof_system/circuit_builder/eccvm/eccvm_circuit_builder.hpp" -#include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp" -#include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp" -#include "barretenberg/translator_vm/goblin_translator_composer.hpp" -#include "barretenberg/ultra_honk/ultra_composer.hpp" - -#include - -using namespace barretenberg; -using namespace proof_system::honk; - -namespace test_full_goblin_composer { - -class FullGoblinComposerTests : public ::testing::Test { - protected: - static void SetUpTestSuite() - { - barretenberg::srs::init_crs_factory("../srs_db/ignition"); - barretenberg::srs::init_grumpkin_crs_factory("../srs_db/grumpkin"); - } - - using Curve = curve::BN254; - using FF = Curve::ScalarField; - using Fbase = Curve::BaseField; - using Point = Curve::AffineElement; - using CommitmentKey = pcs::CommitmentKey; - using OpQueue = proof_system::ECCOpQueue; - using GoblinUltraBuilder = proof_system::GoblinUltraCircuitBuilder; - using ECCVMFlavor = flavor::ECCVM; - using ECCVMBuilder = proof_system::ECCVMCircuitBuilder; - using ECCVMComposer = ECCVMComposer_; - using KernelInput = Goblin::AccumulationOutput; -}; - -/** - * @brief Test proof construction/verification for a circuit with ECC op gates, public inputs, and basic arithmetic - * gates - * @note We simulate op queue interactions with a previous circuit so the actual circuit under test utilizes an op queue - * with non-empty 'previous' data. This avoids complications with zero-commitments etc. - * - */ -TEST_F(FullGoblinComposerTests, SimpleCircuit) -{ - barretenberg::Goblin goblin; - GoblinUltraBuilder initial_circuit{ goblin.op_queue }; - GoblinTestingUtils::construct_simple_initial_circuit(initial_circuit); - KernelInput kernel_input = goblin.accumulate(initial_circuit); - - // Construct a series of simple Goblin circuits; generate and verify their proofs - size_t NUM_CIRCUITS = 2; - for (size_t circuit_idx = 0; circuit_idx < NUM_CIRCUITS; ++circuit_idx) { - GoblinUltraBuilder circuit_builder{ goblin.op_queue }; - GoblinTestingUtils::construct_arithmetic_circuit(circuit_builder); - kernel_input = goblin.accumulate(circuit_builder); - } - - Goblin::Proof proof = goblin.prove(); - bool verified = goblin.verify(proof); - EXPECT_TRUE(verified); -} - -// TODO(https://github.com/AztecProtocol/barretenberg/issues/787) Expand these tests. -} // namespace test_full_goblin_composer diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp index f21c21b92e1f..cb723f586c3e 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp @@ -1,12 +1,12 @@ #include "barretenberg/eccvm/eccvm_composer.hpp" -#include "barretenberg/goblin/goblin.hpp" -#include "barretenberg/goblin/mock_circuits.hpp" -#include "barretenberg/goblin/translation_evaluations.hpp" #include "barretenberg/proof_system/circuit_builder/eccvm/eccvm_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp" +#include "barretenberg/stdlib/recursion/goblin/goblin.hpp" +#include "barretenberg/stdlib/recursion/goblin/mock_circuits.hpp" #include "barretenberg/stdlib/recursion/honk/verifier/ultra_recursive_verifier.hpp" #include "barretenberg/translator_vm/goblin_translator_composer.hpp" +#include "barretenberg/translator_vm/translation_evaluations.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" #include @@ -40,7 +40,8 @@ class GoblinRecursionTests : public ::testing::Test { using NativeVerificationKey = flavor::GoblinUltra::VerificationKey; using RecursiveFlavor = flavor::GoblinUltraRecursive_; using RecursiveVerifier = proof_system::plonk::stdlib::recursion::honk::UltraRecursiveVerifier_; - using KernelInput = Goblin::AccumulationOutput; + using Goblin = proof_system::plonk::stdlib::recursion::goblin::Goblin; + using KernelInput = proof_system::plonk::stdlib::recursion::goblin::Goblin::AccumulationOutput; /** * @brief Construct a mock kernel circuit @@ -72,7 +73,7 @@ class GoblinRecursionTests : public ::testing::Test { */ TEST_F(GoblinRecursionTests, Pseudo) { - barretenberg::Goblin goblin; + Goblin goblin; // Construct an initial circuit; its proof will be recursively verified by the first kernel GoblinUltraBuilder initial_circuit{ goblin.op_queue }; diff --git a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/goblin.hpp similarity index 97% rename from barretenberg/cpp/src/barretenberg/goblin/goblin.hpp rename to barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/goblin.hpp index fb941c0f83eb..a47c13d8269e 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/goblin.hpp @@ -8,7 +8,7 @@ #include "barretenberg/translator_vm/goblin_translator_composer.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" -namespace barretenberg { +namespace proof_system::plonk::stdlib::recursion::goblin { class Goblin { using HonkProof = proof_system::plonk::proof; @@ -68,7 +68,6 @@ class Goblin { // issue (https://github.com/AztecProtocol/barretenberg/issues/723) if (verify_merge) { RecursiveMergeVerifier merge_verifier{ &circuit_builder }; - // Recursively verify the merge proof constructed on the previous call to accumulate [[maybe_unused]] auto pairing_points = merge_verifier.verify_proof(merge_proof); } @@ -115,4 +114,4 @@ class Goblin { return eccvm_verified && accumulator_construction_verified && translation_verified; }; }; -} // namespace barretenberg \ No newline at end of file +} // namespace proof_system::plonk::stdlib::recursion::goblin \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/mock_circuits.hpp similarity index 97% rename from barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp rename to barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/mock_circuits.hpp index cb12bb08c37d..f9688fc6001d 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/mock_circuits.hpp @@ -1,11 +1,10 @@ #include "barretenberg/commitment_schemes/commitment_key.hpp" #include "barretenberg/eccvm/eccvm_composer.hpp" -#include "barretenberg/goblin/goblin.hpp" -#include "barretenberg/goblin/translation_evaluations.hpp" #include "barretenberg/proof_system/circuit_builder/eccvm/eccvm_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp" #include "barretenberg/translator_vm/goblin_translator_composer.hpp" +#include "barretenberg/translator_vm/translation_evaluations.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" namespace barretenberg { diff --git a/barretenberg/cpp/src/barretenberg/translator_vm/goblin_translator_verifier.hpp b/barretenberg/cpp/src/barretenberg/translator_vm/goblin_translator_verifier.hpp index e959eef720e0..82792cca043e 100644 --- a/barretenberg/cpp/src/barretenberg/translator_vm/goblin_translator_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/translator_vm/goblin_translator_verifier.hpp @@ -1,7 +1,7 @@ #pragma once #include "barretenberg/flavor/goblin_translator.hpp" -#include "barretenberg/goblin/translation_evaluations.hpp" #include "barretenberg/plonk/proof_system/types/proof.hpp" +#include "barretenberg/translator_vm/translation_evaluations.hpp" namespace proof_system::honk { class GoblinTranslatorVerifier { diff --git a/barretenberg/cpp/src/barretenberg/goblin/translation_evaluations.hpp b/barretenberg/cpp/src/barretenberg/translator_vm/translation_evaluations.hpp similarity index 100% rename from barretenberg/cpp/src/barretenberg/goblin/translation_evaluations.hpp rename to barretenberg/cpp/src/barretenberg/translator_vm/translation_evaluations.hpp From d8af68294d1c44d77efe82375e50bf9f606b61a4 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Wed, 6 Dec 2023 21:16:55 +0000 Subject: [PATCH 07/15] delete commented out code --- .../recursion/goblin/full_goblin_recursion.test.cpp | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp index cb723f586c3e..1ddc7fdc0f9f 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp @@ -79,16 +79,7 @@ TEST_F(GoblinRecursionTests, Pseudo) GoblinUltraBuilder initial_circuit{ goblin.op_queue }; GoblinTestingUtils::construct_simple_initial_circuit(initial_circuit); - // GoblinUltraComposer composer; - // auto instance = composer.create_instance(initial_circuit); - // auto prover = composer.create_prover(instance); - // auto ultra_proof = prover.construct_proof(); - - // auto merge_prover = composer.create_merge_prover(goblin.op_queue); - // auto merge_proof = merge_prover.construct_proof(); - - // KernelInput kernel_input = { ultra_proof, instance->verification_key }; - + // Note: On the first call to accumulate there is no merge proof to recursively verify KernelInput kernel_input = goblin.accumulate(initial_circuit, /*verify_merge=*/false); // Construct a series of simple Goblin circuits; generate and verify their proofs From 53a58dab7144cb6d090c466be2fc20f23a74042a Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Wed, 6 Dec 2023 21:24:27 +0000 Subject: [PATCH 08/15] remove goblin tests from bbtests --- barretenberg/cpp/scripts/bb-tests.sh | 1 - 1 file changed, 1 deletion(-) diff --git a/barretenberg/cpp/scripts/bb-tests.sh b/barretenberg/cpp/scripts/bb-tests.sh index 459eb7565937..7e3998e6c494 100755 --- a/barretenberg/cpp/scripts/bb-tests.sh +++ b/barretenberg/cpp/scripts/bb-tests.sh @@ -24,7 +24,6 @@ TESTS=( ecc_tests eccvm_tests flavor_tests - goblin_tests join_split_example_proofs_inner_proof_data_tests join_split_example_proofs_notes_tests numeric_tests From f95133424b98d4962b488dc1e428e09aa5b4df3e Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Wed, 6 Dec 2023 22:22:03 +0000 Subject: [PATCH 09/15] move goblin back out of stdlib --- barretenberg/cpp/scripts/bb-tests.sh | 1 + barretenberg/cpp/src/CMakeLists.txt | 1 + .../cpp/src/barretenberg/eccvm/eccvm_prover.hpp | 2 +- .../cpp/src/barretenberg/goblin/CMakeLists.txt | 1 + .../goblin/full_goblin_recursion.test.cpp | 16 +++++++--------- .../{stdlib/recursion => }/goblin/goblin.hpp | 9 ++++++++- .../recursion => }/goblin/mock_circuits.hpp | 2 +- .../translation_evaluations.hpp | 0 .../translator_vm/goblin_translator_verifier.hpp | 2 +- 9 files changed, 21 insertions(+), 13 deletions(-) create mode 100644 barretenberg/cpp/src/barretenberg/goblin/CMakeLists.txt rename barretenberg/cpp/src/barretenberg/{stdlib/recursion => }/goblin/full_goblin_recursion.test.cpp (90%) rename barretenberg/cpp/src/barretenberg/{stdlib/recursion => }/goblin/goblin.hpp (96%) rename barretenberg/cpp/src/barretenberg/{stdlib/recursion => }/goblin/mock_circuits.hpp (98%) rename barretenberg/cpp/src/barretenberg/{translator_vm => goblin}/translation_evaluations.hpp (100%) diff --git a/barretenberg/cpp/scripts/bb-tests.sh b/barretenberg/cpp/scripts/bb-tests.sh index 7e3998e6c494..529621e43187 100755 --- a/barretenberg/cpp/scripts/bb-tests.sh +++ b/barretenberg/cpp/scripts/bb-tests.sh @@ -32,6 +32,7 @@ TESTS=( protogalaxy_tests relations_tests srs_tests + goblin_tests sumcheck_tests transcript_tests translator_vm_tests diff --git a/barretenberg/cpp/src/CMakeLists.txt b/barretenberg/cpp/src/CMakeLists.txt index b5368f0ee948..8f3ee4289c56 100644 --- a/barretenberg/cpp/src/CMakeLists.txt +++ b/barretenberg/cpp/src/CMakeLists.txt @@ -58,6 +58,7 @@ add_subdirectory(barretenberg/eccvm) add_subdirectory(barretenberg/env) add_subdirectory(barretenberg/examples) add_subdirectory(barretenberg/flavor) +add_subdirectory(barretenberg/goblin) add_subdirectory(barretenberg/grumpkin_srs_gen) add_subdirectory(barretenberg/honk) add_subdirectory(barretenberg/join_split_example) diff --git a/barretenberg/cpp/src/barretenberg/eccvm/eccvm_prover.hpp b/barretenberg/cpp/src/barretenberg/eccvm/eccvm_prover.hpp index 3881b4e9d69d..af6f4ec457f6 100644 --- a/barretenberg/cpp/src/barretenberg/eccvm/eccvm_prover.hpp +++ b/barretenberg/cpp/src/barretenberg/eccvm/eccvm_prover.hpp @@ -2,11 +2,11 @@ #include "barretenberg/commitment_schemes/gemini/gemini.hpp" #include "barretenberg/commitment_schemes/shplonk/shplonk.hpp" #include "barretenberg/flavor/ecc_vm.hpp" +#include "barretenberg/goblin/translation_evaluations.hpp" #include "barretenberg/plonk/proof_system/types/proof.hpp" #include "barretenberg/relations/relation_parameters.hpp" #include "barretenberg/sumcheck/sumcheck_output.hpp" #include "barretenberg/transcript/transcript.hpp" -#include "barretenberg/translator_vm/translation_evaluations.hpp" namespace proof_system::honk { diff --git a/barretenberg/cpp/src/barretenberg/goblin/CMakeLists.txt b/barretenberg/cpp/src/barretenberg/goblin/CMakeLists.txt new file mode 100644 index 000000000000..adaa9814aed9 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/goblin/CMakeLists.txt @@ -0,0 +1 @@ +barretenberg_module(goblin stdlib_recursion ultra_honk eccvm translator_vm) \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp similarity index 90% rename from barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp rename to barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp index 1ddc7fdc0f9f..1a7e97c3eaa6 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/full_goblin_recursion.test.cpp +++ b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp @@ -1,12 +1,12 @@ #include "barretenberg/eccvm/eccvm_composer.hpp" +#include "barretenberg/goblin/goblin.hpp" +#include "barretenberg/goblin/mock_circuits.hpp" +#include "barretenberg/goblin/translation_evaluations.hpp" #include "barretenberg/proof_system/circuit_builder/eccvm/eccvm_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp" -#include "barretenberg/stdlib/recursion/goblin/goblin.hpp" -#include "barretenberg/stdlib/recursion/goblin/mock_circuits.hpp" #include "barretenberg/stdlib/recursion/honk/verifier/ultra_recursive_verifier.hpp" #include "barretenberg/translator_vm/goblin_translator_composer.hpp" -#include "barretenberg/translator_vm/translation_evaluations.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" #include @@ -24,10 +24,6 @@ class GoblinRecursionTests : public ::testing::Test { using Curve = curve::BN254; using FF = Curve::ScalarField; - using Fbase = Curve::BaseField; - using Point = Curve::AffineElement; - using CommitmentKey = pcs::CommitmentKey; - using OpQueue = proof_system::ECCOpQueue; using GoblinUltraBuilder = proof_system::GoblinUltraCircuitBuilder; using ECCVMFlavor = flavor::ECCVM; using ECCVMBuilder = proof_system::ECCVMCircuitBuilder; @@ -36,8 +32,6 @@ class GoblinRecursionTests : public ::testing::Test { using TranslatorBuilder = proof_system::GoblinTranslatorCircuitBuilder; using TranslatorComposer = GoblinTranslatorComposer; using TranslatorConsistencyData = barretenberg::TranslationEvaluations; - using Proof = proof_system::plonk::proof; - using NativeVerificationKey = flavor::GoblinUltra::VerificationKey; using RecursiveFlavor = flavor::GoblinUltraRecursive_; using RecursiveVerifier = proof_system::plonk::stdlib::recursion::honk::UltraRecursiveVerifier_; using Goblin = proof_system::plonk::stdlib::recursion::goblin::Goblin; @@ -93,6 +87,10 @@ TEST_F(GoblinRecursionTests, Pseudo) kernel_input = goblin.accumulate(circuit_builder); } + // WORKTODO: need to verify final ultra and merge proofs to complete the test + + // verify(kernel_input.proof) + Goblin::Proof proof = goblin.prove(); bool verified = goblin.verify(proof); EXPECT_TRUE(verified); diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/goblin.hpp b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp similarity index 96% rename from barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/goblin.hpp rename to barretenberg/cpp/src/barretenberg/goblin/goblin.hpp index a47c13d8269e..06244edb13e9 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/goblin.hpp +++ b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp @@ -25,6 +25,7 @@ class Goblin { }; struct Proof { + HonkProof merge_proof; HonkProof eccvm_proof; HonkProof translator_proof; TranslationEvaluations translation_evaluations; @@ -46,7 +47,7 @@ class Goblin { proof_system::plonk::stdlib::recursion::goblin::MergeRecursiveVerifier_; std::shared_ptr op_queue = std::make_shared(); - HonkProof merge_proof; + HonkProof merge_proof; // WORKTODO private: // TODO(https://github.com/AztecProtocol/barretenberg/issues/798) unique_ptr use is a hack @@ -87,6 +88,9 @@ class Goblin { Proof prove() { Proof proof; + // WORKTODO: std::move + // proof.merge_proof = merge_proof; + eccvm_builder = std::make_unique(op_queue); eccvm_composer = std::make_unique(); auto eccvm_prover = eccvm_composer->create_prover(*eccvm_builder); @@ -103,6 +107,9 @@ class Goblin { bool verify(const Proof& proof) { + + // WORKTODO: native merge verify + auto eccvm_verifier = eccvm_composer->create_verifier(*eccvm_builder); bool eccvm_verified = eccvm_verifier.verify_proof(proof.eccvm_proof); diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/mock_circuits.hpp b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp similarity index 98% rename from barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/mock_circuits.hpp rename to barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp index f9688fc6001d..51f33deef9b2 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/goblin/mock_circuits.hpp +++ b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp @@ -1,10 +1,10 @@ #include "barretenberg/commitment_schemes/commitment_key.hpp" #include "barretenberg/eccvm/eccvm_composer.hpp" +#include "barretenberg/goblin/translation_evaluations.hpp" #include "barretenberg/proof_system/circuit_builder/eccvm/eccvm_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp" #include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp" #include "barretenberg/translator_vm/goblin_translator_composer.hpp" -#include "barretenberg/translator_vm/translation_evaluations.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" namespace barretenberg { diff --git a/barretenberg/cpp/src/barretenberg/translator_vm/translation_evaluations.hpp b/barretenberg/cpp/src/barretenberg/goblin/translation_evaluations.hpp similarity index 100% rename from barretenberg/cpp/src/barretenberg/translator_vm/translation_evaluations.hpp rename to barretenberg/cpp/src/barretenberg/goblin/translation_evaluations.hpp diff --git a/barretenberg/cpp/src/barretenberg/translator_vm/goblin_translator_verifier.hpp b/barretenberg/cpp/src/barretenberg/translator_vm/goblin_translator_verifier.hpp index 82792cca043e..e959eef720e0 100644 --- a/barretenberg/cpp/src/barretenberg/translator_vm/goblin_translator_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/translator_vm/goblin_translator_verifier.hpp @@ -1,7 +1,7 @@ #pragma once #include "barretenberg/flavor/goblin_translator.hpp" +#include "barretenberg/goblin/translation_evaluations.hpp" #include "barretenberg/plonk/proof_system/types/proof.hpp" -#include "barretenberg/translator_vm/translation_evaluations.hpp" namespace proof_system::honk { class GoblinTranslatorVerifier { From 721a3d1a8ffbd259bcc05887ff82619e8ad72321 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Wed, 6 Dec 2023 22:49:32 +0000 Subject: [PATCH 10/15] cleanup --- .../goblin/full_goblin_recursion.test.cpp | 9 +++------ .../cpp/src/barretenberg/goblin/goblin.hpp | 16 +++++++++------- .../ultra_honk/goblin_ultra_composer.test.cpp | 2 +- .../barretenberg/ultra_honk/ultra_composer.hpp | 6 ++++-- 4 files changed, 17 insertions(+), 16 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp index 1a7e97c3eaa6..d336e619e1e8 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp +++ b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp @@ -34,8 +34,8 @@ class GoblinRecursionTests : public ::testing::Test { using TranslatorConsistencyData = barretenberg::TranslationEvaluations; using RecursiveFlavor = flavor::GoblinUltraRecursive_; using RecursiveVerifier = proof_system::plonk::stdlib::recursion::honk::UltraRecursiveVerifier_; - using Goblin = proof_system::plonk::stdlib::recursion::goblin::Goblin; - using KernelInput = proof_system::plonk::stdlib::recursion::goblin::Goblin::AccumulationOutput; + using Goblin = barretenberg::Goblin; + using KernelInput = Goblin::AccumulationOutput; /** * @brief Construct a mock kernel circuit @@ -87,11 +87,8 @@ TEST_F(GoblinRecursionTests, Pseudo) kernel_input = goblin.accumulate(circuit_builder); } - // WORKTODO: need to verify final ultra and merge proofs to complete the test - - // verify(kernel_input.proof) - Goblin::Proof proof = goblin.prove(); + // WORKTODO: verify(kernel_input.proof) bool verified = goblin.verify(proof); EXPECT_TRUE(verified); } diff --git a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp index 06244edb13e9..e00f11ad80df 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp +++ b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp @@ -8,7 +8,7 @@ #include "barretenberg/translator_vm/goblin_translator_composer.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" -namespace proof_system::plonk::stdlib::recursion::goblin { +namespace barretenberg { class Goblin { using HonkProof = proof_system::plonk::proof; @@ -88,8 +88,8 @@ class Goblin { Proof prove() { Proof proof; - // WORKTODO: std::move - // proof.merge_proof = merge_proof; + + proof.merge_proof = std::move(merge_proof); eccvm_builder = std::make_unique(op_queue); eccvm_composer = std::make_unique(); @@ -107,8 +107,9 @@ class Goblin { bool verify(const Proof& proof) { - - // WORKTODO: native merge verify + GoblinUltraComposer composer; + auto merge_verifier = composer.create_merge_verifier(0); + bool merge_verified = merge_verifier.verify_proof(proof.merge_proof); auto eccvm_verifier = eccvm_composer->create_verifier(*eccvm_builder); bool eccvm_verified = eccvm_verifier.verify_proof(proof.eccvm_proof); @@ -118,7 +119,8 @@ class Goblin { // TODO(https://github.com/AztecProtocol/barretenberg/issues/799): // Ensure translation_evaluations are passed correctly bool translation_verified = translator_verifier.verify_translation(proof.translation_evaluations); - return eccvm_verified && accumulator_construction_verified && translation_verified; + + return merge_verified && eccvm_verified && accumulator_construction_verified && translation_verified; }; }; -} // namespace proof_system::plonk::stdlib::recursion::goblin \ No newline at end of file +} // namespace barretenberg \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/goblin_ultra_composer.test.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/goblin_ultra_composer.test.cpp index a09a822085b4..52bc8aa9a03c 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/goblin_ultra_composer.test.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/goblin_ultra_composer.test.cpp @@ -77,7 +77,7 @@ class GoblinUltraHonkComposerTests : public ::testing::Test { bool construct_and_verify_merge_proof(auto& composer, auto& op_queue) { auto merge_prover = composer.create_merge_prover(op_queue); - auto merge_verifier = composer.create_merge_verifier(10); + auto merge_verifier = composer.create_merge_verifier(); auto merge_proof = merge_prover.construct_proof(); bool verified = merge_verifier.verify_proof(merge_proof); diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.hpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.hpp index cdfb202db398..95441ac8f4c0 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.hpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.hpp @@ -68,6 +68,8 @@ template class UltraComposer_ { * * @param op_queue * @return MergeProver_ + * TODO(https://github.com/AztecProtocol/barretenberg/issues/804): Goblin should be responsible for constructing + * merge prover/verifier. */ MergeProver_ create_merge_prover( const std::shared_ptr& op_queue, @@ -88,9 +90,9 @@ template class UltraComposer_ { * @return MergeVerifier_ */ MergeVerifier_ create_merge_verifier( - size_t srs_size, const std::shared_ptr& transcript = std::make_shared()) + const std::shared_ptr& transcript = std::make_shared()) { - auto pcs_verification_key = std::make_unique(srs_size, crs_factory_); + auto pcs_verification_key = std::make_unique(0, crs_factory_); return MergeVerifier_(std::move(pcs_verification_key), transcript); } From 1a490f21bf5e3005ab43ae900ad390feee497c4d Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Wed, 6 Dec 2023 23:05:01 +0000 Subject: [PATCH 11/15] more clean --- barretenberg/cpp/scripts/bb-tests.sh | 2 +- .../goblin/full_goblin_recursion.test.cpp | 4 ++-- .../cpp/src/barretenberg/goblin/goblin.hpp | 20 ++++++++++++------- .../src/barretenberg/goblin/mock_circuits.hpp | 7 +------ .../honk/verifier/merge_verifier.test.cpp | 4 ++-- 5 files changed, 19 insertions(+), 18 deletions(-) diff --git a/barretenberg/cpp/scripts/bb-tests.sh b/barretenberg/cpp/scripts/bb-tests.sh index 529621e43187..459eb7565937 100755 --- a/barretenberg/cpp/scripts/bb-tests.sh +++ b/barretenberg/cpp/scripts/bb-tests.sh @@ -24,6 +24,7 @@ TESTS=( ecc_tests eccvm_tests flavor_tests + goblin_tests join_split_example_proofs_inner_proof_data_tests join_split_example_proofs_notes_tests numeric_tests @@ -32,7 +33,6 @@ TESTS=( protogalaxy_tests relations_tests srs_tests - goblin_tests sumcheck_tests transcript_tests translator_vm_tests diff --git a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp index d336e619e1e8..6bcb23b279cc 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp +++ b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp @@ -57,7 +57,7 @@ class GoblinRecursionTests : public ::testing::Test { // TODO(https://github.com/AztecProtocol/barretenberg/issues/803): Mock app circuit. In the absence of a mocked // app circuit proof, we simply perform another recursive verification for the previous kernel proof to // approximate the work done for the app proof. - pairing_points = verifier.verify_proof(kernel_input.proof); // app function proof + pairing_points = verifier.verify_proof(kernel_input.proof); } }; @@ -74,7 +74,7 @@ TEST_F(GoblinRecursionTests, Pseudo) GoblinTestingUtils::construct_simple_initial_circuit(initial_circuit); // Note: On the first call to accumulate there is no merge proof to recursively verify - KernelInput kernel_input = goblin.accumulate(initial_circuit, /*verify_merge=*/false); + KernelInput kernel_input = goblin.accumulate(initial_circuit); // Construct a series of simple Goblin circuits; generate and verify their proofs size_t NUM_CIRCUITS = 2; diff --git a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp index e00f11ad80df..6512cbdab832 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp +++ b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp @@ -47,7 +47,11 @@ class Goblin { proof_system::plonk::stdlib::recursion::goblin::MergeRecursiveVerifier_; std::shared_ptr op_queue = std::make_shared(); - HonkProof merge_proof; // WORKTODO + + HonkProof merge_proof; + + // on the first call to accumulate there is no merge proof to verify + bool merge_proof_exists{ false }; private: // TODO(https://github.com/AztecProtocol/barretenberg/issues/798) unique_ptr use is a hack @@ -62,12 +66,10 @@ class Goblin { * * @param circuit_builder */ - AccumulationOutput accumulate(GoblinUltraCircuitBuilder& circuit_builder, bool verify_merge = true) + AccumulationOutput accumulate(GoblinUltraCircuitBuilder& circuit_builder) { - // Complete the circuit logic by recursively verifying previous merge proof - // Note: the first time we call accumulate there is no merge proof to recursively verify. This is related to - // issue (https://github.com/AztecProtocol/barretenberg/issues/723) - if (verify_merge) { + // Complete the circuit logic by recursively verifying previous merge proof if it exists + if (merge_proof_exists) { RecursiveMergeVerifier merge_verifier{ &circuit_builder }; [[maybe_unused]] auto pairing_points = merge_verifier.verify_proof(merge_proof); } @@ -82,6 +84,10 @@ class Goblin { auto merge_prover = composer.create_merge_prover(op_queue); merge_proof = merge_prover.construct_proof(); + if (!merge_proof_exists) { + merge_proof_exists = true; + } + return { ultra_proof, instance->verification_key }; }; @@ -108,7 +114,7 @@ class Goblin { bool verify(const Proof& proof) { GoblinUltraComposer composer; - auto merge_verifier = composer.create_merge_verifier(0); + auto merge_verifier = composer.create_merge_verifier(); bool merge_verified = merge_verifier.verify_proof(proof.merge_proof); auto eccvm_verifier = eccvm_composer->create_verifier(*eccvm_builder); diff --git a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp index 51f33deef9b2..eaaaa67816de 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp +++ b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp @@ -1,11 +1,6 @@ #include "barretenberg/commitment_schemes/commitment_key.hpp" -#include "barretenberg/eccvm/eccvm_composer.hpp" -#include "barretenberg/goblin/translation_evaluations.hpp" -#include "barretenberg/proof_system/circuit_builder/eccvm/eccvm_circuit_builder.hpp" +#include "barretenberg/flavor/goblin_ultra.hpp" #include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp" -#include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp" -#include "barretenberg/translator_vm/goblin_translator_composer.hpp" -#include "barretenberg/ultra_honk/ultra_composer.hpp" namespace barretenberg { class GoblinTestingUtils { diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp index f7c129d232a4..40cb1afcf28e 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp @@ -87,7 +87,7 @@ class RecursiveMergeVerifierTest : public testing::Test { // Construct and natively verify the merge proof InnerComposer composer; auto merge_prover = composer.create_merge_prover(op_queue); - auto merge_verifier = composer.create_merge_verifier(0); + auto merge_verifier = composer.create_merge_verifier(); auto merge_proof = merge_prover.construct_proof(); bool verified = merge_verifier.verify_proof(merge_proof); EXPECT_TRUE(verified); @@ -122,7 +122,7 @@ class RecursiveMergeVerifierTest : public testing::Test { // Check 1: Perform native merge verification then perform the pairing on the outputs of the recursive merge // verifier and check that the result agrees. - auto native_verifier = inner_composer.create_merge_verifier(0); + auto native_verifier = inner_composer.create_merge_verifier(); bool verified_native = native_verifier.verify_proof(merge_proof); VerifierCommitmentKey pcs_verification_key(0, srs::get_crs_factory()); auto verified_recursive = From 1fb1afba8976c25900f7f8ddcf9259e5732abb8b Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Wed, 6 Dec 2023 23:26:11 +0000 Subject: [PATCH 12/15] simplify rec merge verifier tests --- .../goblin/full_goblin_recursion.test.cpp | 1 - .../src/barretenberg/goblin/mock_circuits.hpp | 1 + .../honk/verifier/merge_verifier.test.cpp | 71 +------------------ 3 files changed, 4 insertions(+), 69 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp index 6bcb23b279cc..500bade8cd5a 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp +++ b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp @@ -73,7 +73,6 @@ TEST_F(GoblinRecursionTests, Pseudo) GoblinUltraBuilder initial_circuit{ goblin.op_queue }; GoblinTestingUtils::construct_simple_initial_circuit(initial_circuit); - // Note: On the first call to accumulate there is no merge proof to recursively verify KernelInput kernel_input = goblin.accumulate(initial_circuit); // Construct a series of simple Goblin circuits; generate and verify their proofs diff --git a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp index eaaaa67816de..5199a65ab632 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp +++ b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp @@ -1,6 +1,7 @@ #include "barretenberg/commitment_schemes/commitment_key.hpp" #include "barretenberg/flavor/goblin_ultra.hpp" #include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp" +#include "barretenberg/srs/global_crs.hpp" namespace barretenberg { class GoblinTestingUtils { diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp index 40cb1afcf28e..39b981c4b6a0 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/merge_verifier.test.cpp @@ -1,4 +1,5 @@ #include "barretenberg/common/test.hpp" +#include "barretenberg/goblin/mock_circuits.hpp" #include "barretenberg/stdlib/primitives/curves/bn254.hpp" #include "barretenberg/stdlib/recursion/honk/verifier/merge_recursive_verifier.hpp" #include "barretenberg/ultra_honk/ultra_composer.hpp" @@ -30,69 +31,9 @@ class RecursiveMergeVerifierTest : public testing::Test { using FF = InnerFlavor::FF; using VerifierCommitmentKey = ::proof_system::honk::pcs::VerifierCommitmentKey; - /** - * @brief Generate a simple test circuit with some ECC op gates and conventional arithmetic gates - * - * @param builder - */ - static proof_system::GoblinUltraCircuitBuilder generate_sample_circuit(const std::shared_ptr& op_queue) - { - // Create an arbitrary inner circuit - InnerBuilder builder{ op_queue }; - - // Add some arbitrary ecc op gates - for (size_t i = 0; i < 3; ++i) { - auto point = Commitment::random_element(); - auto scalar = FF::random_element(); - builder.queue_ecc_add_accum(point); - builder.queue_ecc_mul_accum(point, scalar); - } - // queues the result of the preceding ECC - builder.queue_ecc_eq(); // should be eq and reset - - // Add some conventional gates that utilize public inputs - for (size_t i = 0; i < 10; ++i) { - FF a = FF::random_element(); - FF b = FF::random_element(); - FF c = FF::random_element(); - FF d = a + b + c; - uint32_t a_idx = builder.add_public_variable(a); - uint32_t b_idx = builder.add_variable(b); - uint32_t c_idx = builder.add_variable(c); - uint32_t d_idx = builder.add_variable(d); - - builder.create_big_add_gate({ a_idx, b_idx, c_idx, d_idx, FF(1), FF(1), FF(1), FF(-1), FF(0) }); - } - - return builder; - } - public: static void SetUpTestSuite() { barretenberg::srs::init_crs_factory("../srs_db/ignition"); } - /** - * @brief Test native merge proof construction/verification for the sample circuit - * - */ - static void test_sample_circuit_merge() - { - auto op_queue = std::make_shared(); - - // Populate op queue with mock initial data since we don't handle the empty previous aggregate transcript case - op_queue->populate_with_mock_initital_data(); - - // Create an arbitrary inner circuit with goblin ECC op gates - InnerBuilder sample_circuit = generate_sample_circuit(op_queue); - - // Construct and natively verify the merge proof - InnerComposer composer; - auto merge_prover = composer.create_merge_prover(op_queue); - auto merge_verifier = composer.create_merge_verifier(); - auto merge_proof = merge_prover.construct_proof(); - bool verified = merge_verifier.verify_proof(merge_proof); - EXPECT_TRUE(verified); - } - /** * @brief Test recursive merge verification for the ops generated by a sample circuit * @details We construct and verify an Ultra Honk proof of the recursive merge verifier circuit to check its @@ -102,10 +43,9 @@ class RecursiveMergeVerifierTest : public testing::Test { static void test_recursive_merge_verification() { auto op_queue = std::make_shared(); - op_queue->populate_with_mock_initital_data(); - // Create an arbitrary inner circuit - InnerBuilder inner_circuit = generate_sample_circuit(op_queue); + InnerBuilder sample_circuit{ op_queue }; + GoblinTestingUtils::construct_simple_initial_circuit(sample_circuit); // Generate a proof over the inner circuit InnerComposer inner_composer; @@ -152,11 +92,6 @@ class RecursiveMergeVerifierTest : public testing::Test { } }; -TEST_F(RecursiveMergeVerifierTest, NativeSampleCircuitMerge) -{ - RecursiveMergeVerifierTest::test_sample_circuit_merge(); -}; - TEST_F(RecursiveMergeVerifierTest, SingleRecursiveVerification) { RecursiveMergeVerifierTest::test_recursive_merge_verification(); From 94da6b413827cd57086e5830afc69b5a18abd73d Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Thu, 7 Dec 2023 16:36:48 +0000 Subject: [PATCH 13/15] verifying final ultra proof --- .../barretenberg/goblin/full_goblin_recursion.test.cpp | 8 ++++++-- .../cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp | 7 +++++++ .../cpp/src/barretenberg/ultra_honk/ultra_verifier.hpp | 2 ++ 3 files changed, 15 insertions(+), 2 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp index 500bade8cd5a..2adc5049600d 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp +++ b/barretenberg/cpp/src/barretenberg/goblin/full_goblin_recursion.test.cpp @@ -36,6 +36,7 @@ class GoblinRecursionTests : public ::testing::Test { using RecursiveVerifier = proof_system::plonk::stdlib::recursion::honk::UltraRecursiveVerifier_; using Goblin = barretenberg::Goblin; using KernelInput = Goblin::AccumulationOutput; + using UltraVerifier = UltraVerifier_; /** * @brief Construct a mock kernel circuit @@ -87,9 +88,12 @@ TEST_F(GoblinRecursionTests, Pseudo) } Goblin::Proof proof = goblin.prove(); - // WORKTODO: verify(kernel_input.proof) + // Verify the final ultra proof + UltraVerifier ultra_verifier{ kernel_input.verification_key }; + bool ultra_verified = ultra_verifier.verify_proof(kernel_input.proof); + // Verify the goblin proof (eccvm, translator, merge) bool verified = goblin.verify(proof); - EXPECT_TRUE(verified); + EXPECT_TRUE(ultra_verified && verified); } // TODO(https://github.com/AztecProtocol/barretenberg/issues/787) Expand these tests. diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp index df70e5ac12cf..c781e0383525 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp @@ -15,6 +15,13 @@ UltraVerifier_::UltraVerifier_(const std::shared_ptr& transc , transcript(transcript) {} +template +UltraVerifier_::UltraVerifier_(const std::shared_ptr& verifier_key) + : key(verifier_key) + , pcs_verification_key(std::make_unique(0, barretenberg::srs::get_crs_factory())) + , transcript(std::make_shared()) +{} + template UltraVerifier_::UltraVerifier_(UltraVerifier_&& other) : key(std::move(other.key)) diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.hpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.hpp index 6a023071f025..8197e46a9412 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.hpp @@ -2,6 +2,7 @@ #include "barretenberg/flavor/goblin_ultra.hpp" #include "barretenberg/flavor/ultra.hpp" #include "barretenberg/plonk/proof_system/types/proof.hpp" +#include "barretenberg/srs/global_crs.hpp" #include "barretenberg/sumcheck/sumcheck.hpp" namespace proof_system::honk { @@ -15,6 +16,7 @@ template class UltraVerifier_ { public: explicit UltraVerifier_(const std::shared_ptr& transcript, const std::shared_ptr& verifier_key = nullptr); + explicit UltraVerifier_(const std::shared_ptr& verifier_key); UltraVerifier_(UltraVerifier_&& other); UltraVerifier_& operator=(const UltraVerifier_& other) = delete; From 07bd3f35e8db44fc96bf3cbc9e293794c24fe6e4 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Thu, 7 Dec 2023 17:07:18 +0000 Subject: [PATCH 14/15] construct a merge verifier directly --- barretenberg/cpp/src/barretenberg/goblin/goblin.hpp | 5 +++-- .../cpp/src/barretenberg/ultra_honk/merge_verifier.cpp | 5 +++++ .../cpp/src/barretenberg/ultra_honk/merge_verifier.hpp | 2 ++ 3 files changed, 10 insertions(+), 2 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp index 6512cbdab832..3c2588288dfa 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp +++ b/barretenberg/cpp/src/barretenberg/goblin/goblin.hpp @@ -45,6 +45,7 @@ class Goblin { using TranslatorComposer = proof_system::honk::GoblinTranslatorComposer; using RecursiveMergeVerifier = proof_system::plonk::stdlib::recursion::goblin::MergeRecursiveVerifier_; + using MergeVerifier = proof_system::honk::MergeVerifier_; std::shared_ptr op_queue = std::make_shared(); @@ -108,13 +109,13 @@ class Goblin { translator_composer = std::make_unique(); auto translator_prover = translator_composer->create_prover(*translator_builder, eccvm_prover.transcript); proof.translator_proof = translator_prover.construct_proof(); + return proof; }; bool verify(const Proof& proof) { - GoblinUltraComposer composer; - auto merge_verifier = composer.create_merge_verifier(); + MergeVerifier merge_verifier; bool merge_verified = merge_verifier.verify_proof(proof.merge_proof); auto eccvm_verifier = eccvm_composer->create_verifier(*eccvm_builder); diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.cpp index c93257af7de7..01ce96096451 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.cpp @@ -8,6 +8,11 @@ MergeVerifier_::MergeVerifier_(std::unique_ptr ve : transcript(transcript) , pcs_verification_key(std::move(verification_key)){}; +template +MergeVerifier_::MergeVerifier_() + : transcript(std::make_shared()) + , pcs_verification_key(std::make_unique(0, barretenberg::srs::get_crs_factory())){}; + /** * @brief Verify proper construction of the aggregate Goblin ECC op queue polynomials T_i^(j), j = 1,2,3,4. * @details Let T_i^(j) be the jth column of the aggregate op queue after incorporating the contribution from the diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.hpp b/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.hpp index d6880476b794..10fb5fcda7d4 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.hpp @@ -5,6 +5,7 @@ #include "barretenberg/flavor/ultra.hpp" #include "barretenberg/plonk/proof_system/types/proof.hpp" #include "barretenberg/proof_system/op_queue/ecc_op_queue.hpp" +#include "barretenberg/srs/global_crs.hpp" #include "barretenberg/transcript/transcript.hpp" namespace proof_system::honk { @@ -33,6 +34,7 @@ template class MergeVerifier_ { explicit MergeVerifier_(std::unique_ptr verification_key, const std::shared_ptr& transcript); + explicit MergeVerifier_(); bool verify_proof(const plonk::proof& proof); }; From b4a4f3947996dd587916ac9e55654e1bca0e5986 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Thu, 7 Dec 2023 17:20:02 +0000 Subject: [PATCH 15/15] cleanup --- .../cpp/src/barretenberg/ultra_honk/merge_verifier.cpp | 6 ------ .../cpp/src/barretenberg/ultra_honk/merge_verifier.hpp | 2 -- .../cpp/src/barretenberg/ultra_honk/ultra_composer.hpp | 8 +------- .../cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp | 6 ++++++ 4 files changed, 7 insertions(+), 15 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.cpp index 01ce96096451..ebf18518afa8 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.cpp @@ -2,12 +2,6 @@ namespace proof_system::honk { -template -MergeVerifier_::MergeVerifier_(std::unique_ptr verification_key, - const std::shared_ptr& transcript) - : transcript(transcript) - , pcs_verification_key(std::move(verification_key)){}; - template MergeVerifier_::MergeVerifier_() : transcript(std::make_shared()) diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.hpp b/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.hpp index 10fb5fcda7d4..da094df6b7e9 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/merge_verifier.hpp @@ -32,8 +32,6 @@ template class MergeVerifier_ { std::shared_ptr op_queue; std::shared_ptr pcs_verification_key; - explicit MergeVerifier_(std::unique_ptr verification_key, - const std::shared_ptr& transcript); explicit MergeVerifier_(); bool verify_proof(const plonk::proof& proof); }; diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.hpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.hpp index 95441ac8f4c0..0d4dd752d080 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.hpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.hpp @@ -86,15 +86,9 @@ template class UltraComposer_ { /** * @brief Create Verifier for Goblin ECC op queue merge protocol * - * @param size Size of commitment key required to commit to shifted op queue contribution t_i * @return MergeVerifier_ */ - MergeVerifier_ create_merge_verifier( - const std::shared_ptr& transcript = std::make_shared()) - { - auto pcs_verification_key = std::make_unique(0, crs_factory_); - return MergeVerifier_(std::move(pcs_verification_key), transcript); - } + MergeVerifier_ create_merge_verifier() { return MergeVerifier_(); } ProtoGalaxyProver_ create_folding_prover(const std::vector>& instances) { diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp index c781e0383525..2775b586c7ee 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp @@ -15,6 +15,12 @@ UltraVerifier_::UltraVerifier_(const std::shared_ptr& transc , transcript(transcript) {} +/** + * @brief Construct an UltraVerifier directly from a verification key + * + * @tparam Flavor + * @param verifier_key + */ template UltraVerifier_::UltraVerifier_(const std::shared_ptr& verifier_key) : key(verifier_key)