From e1450b688c1bc9fadfb84b0b26598554f907dfc6 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Thu, 18 Apr 2024 20:39:40 +0000 Subject: [PATCH 1/7] structured trace toy example verifies --- .../execution_trace/execution_trace.cpp | 14 +++++--- .../execution_trace/execution_trace.hpp | 6 ++-- .../arithmetization/arithmetization.hpp | 2 ++ .../standard_circuit_builder.hpp | 1 + .../ultra_circuit_builder.hpp | 1 + .../sumcheck/instance/prover_instance.hpp | 30 ++++++++++++++-- .../ultra_honk/ultra_composer.test.cpp | 34 +++++++++++++++++++ 7 files changed, 79 insertions(+), 9 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.cpp b/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.cpp index b232fa00799..79442b91bea 100644 --- a/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.cpp @@ -6,10 +6,10 @@ namespace bb { template -void ExecutionTrace_::populate(Builder& builder, typename Flavor::ProvingKey& proving_key) +void ExecutionTrace_::populate(Builder& builder, typename Flavor::ProvingKey& proving_key, bool is_structured) { // Construct wire polynomials, selector polynomials, and copy cycles from raw circuit data - auto trace_data = construct_trace_data(builder, proving_key.circuit_size); + auto trace_data = construct_trace_data(builder, proving_key.circuit_size, is_structured); add_wires_and_selectors_to_proving_key(trace_data, builder, proving_key); @@ -69,7 +69,8 @@ void ExecutionTrace_::add_memory_records_to_proving_key(TraceData& trace template typename ExecutionTrace_::TraceData ExecutionTrace_::construct_trace_data(Builder& builder, - size_t dyadic_circuit_size) + size_t dyadic_circuit_size, + bool is_structured) { TraceData trace_data{ dyadic_circuit_size, builder }; @@ -113,7 +114,12 @@ typename ExecutionTrace_::TraceData ExecutionTrace_::construct_t trace_data.pub_inputs_offset = offset; } - offset += block_size; + // If the trace is structured, we populate the data from the next block at a fixed block size offset + if (is_structured) { + offset += builder.FIXED_BLOCK_SIZE; + } else { // otherwise, the next block starts immediately following the previous one + offset += block_size; + } } return trace_data; } diff --git a/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.hpp b/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.hpp index 3dd3899242e..08115e052fc 100644 --- a/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.hpp @@ -41,8 +41,9 @@ template class ExecutionTrace_ { * @brief Given a circuit, populate a proving key with wire polys, selector polys, and sigma/id polys * * @param builder + * @param is_structured whether or not the trace is to be structured with a fixed block size */ - static void populate(Builder& builder, ProvingKey&); + static void populate(Builder& builder, ProvingKey&, bool is_structured = false); private: /** @@ -78,9 +79,10 @@ template class ExecutionTrace_ { * * @param builder * @param dyadic_circuit_size + * @param is_structured whether or not the trace is to be structured with a fixed block size * @return TraceData */ - static TraceData construct_trace_data(Builder& builder, size_t dyadic_circuit_size); + static TraceData construct_trace_data(Builder& builder, size_t dyadic_circuit_size, bool is_structured = false); /** * @brief Populate the public inputs block diff --git a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp index eed7d43370d..bbd2b262b42 100644 --- a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp +++ b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp @@ -119,6 +119,7 @@ template class UltraArith { public: static constexpr size_t NUM_WIRES = 4; static constexpr size_t NUM_SELECTORS = 11; + static constexpr size_t FIXED_BLOCK_SIZE = 5; // tiny for testing (5 * 6 = 30 < 2^5) using FF = FF_; class UltraTraceBlock : public ExecutionTraceBlock { @@ -196,6 +197,7 @@ template class UltraHonkArith { public: static constexpr size_t NUM_WIRES = 4; static constexpr size_t NUM_SELECTORS = 14; + static constexpr size_t FIXED_BLOCK_SIZE = 5; // tiny for testing (6 * 10 = 60 < 2^6) using FF = FF_; class UltraHonkTraceBlock : public ExecutionTraceBlock { diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/standard_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/standard_circuit_builder.hpp index e6ede171ffa..a421a10adaa 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/standard_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/standard_circuit_builder.hpp @@ -15,6 +15,7 @@ template class StandardCircuitBuilder_ : public CircuitBuilderBase using Arithmetization = StandardArith; using GateBlocks = typename Arithmetization::TraceBlocks; static constexpr size_t NUM_WIRES = Arithmetization::NUM_WIRES; + static constexpr size_t FIXED_BLOCK_SIZE = 0; // not used, for compatibility only // Keeping NUM_WIRES, at least temporarily, for backward compatibility static constexpr size_t program_width = Arithmetization::NUM_WIRES; static constexpr size_t num_selectors = Arithmetization::NUM_SELECTORS; diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp index feecbf0938d..90dde82d76c 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp @@ -33,6 +33,7 @@ class UltraCircuitBuilder_ : public CircuitBuilderBase class ProverInstance_ { std::vector gate_challenges; FF target_sum; - ProverInstance_(Circuit& circuit) + ProverInstance_(Circuit& circuit, bool is_structured = false) { BB_OP_COUNT_TIME_NAME("ProverInstance(Circuit&)"); circuit.add_gates_to_ensure_all_polys_are_non_zero(); circuit.finalize_circuit(); + // If using a structured trace, ensure that no block exceeds the fixed size + if (is_structured) { + for (auto& block : circuit.blocks.get()) { + ASSERT(block.size() <= circuit.FIXED_BLOCK_SIZE); + } + } + + // TODO(https://github.com/AztecProtocol/barretenberg/issues/905): This is adding ops to the op queue but NOT to + // the circuit, meaning the ECCVM/Translator will use different ops than the main circuit / merge protocol. if constexpr (IsGoblinFlavor) { circuit.op_queue->append_nonzero_ops(); } - dyadic_circuit_size = compute_dyadic_size(circuit); + if (is_structured) { // Compute dyadic size based on a structured trace with fixed block size + dyadic_circuit_size = compute_structured_dyadic_size(circuit); + } else { // Otherwise, compute conventional dyadic circuit size + dyadic_circuit_size = compute_dyadic_size(circuit); + } proving_key = std::move(ProvingKey(dyadic_circuit_size, circuit.public_inputs.size())); // Construct and add to proving key the wire, selector and copy constraint polynomials - Trace::populate(circuit, proving_key); + Trace::populate(circuit, proving_key, is_structured); // If Goblin, construct the databus polynomials if constexpr (IsGoblinFlavor) { @@ -95,6 +108,17 @@ template class ProverInstance_ { size_t compute_dyadic_size(Circuit&); + /** + * @brief Compute dyadic size based on a structured trace with fixed block size + * + */ + size_t compute_structured_dyadic_size(Circuit& builder) + { + size_t num_blocks = builder.blocks.get().size(); + size_t minimum_size = num_blocks * builder.FIXED_BLOCK_SIZE; + return builder.get_circuit_subgroup_size(minimum_size); + } + void construct_databus_polynomials(Circuit&) requires IsGoblinFlavor; diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp index c6015ca160c..600e55e8342 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp @@ -85,6 +85,40 @@ TEST_F(UltraHonkComposerTests, ANonZeroPolynomialIsAGoodPolynomial) } } +/** + * @brief Test proof construction/verification for a structured execution trace + * + */ +TEST_F(UltraHonkComposerTests, StructuredTrace) +{ + auto builder = UltraCircuitBuilder(); + size_t num_gates = 1; + + // Add some arbitrary arithmetic gates that utilize public inputs + for (size_t i = 0; i < num_gates; ++i) { + fr a = fr::random_element(); + uint32_t a_idx = builder.add_public_variable(a); + + fr b = fr::random_element(); + fr c = fr::random_element(); + fr d = a + b + c; + 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, fr(1), fr(1), fr(1), fr(-1), fr(0) }); + } + + // Construct an instance with a structured execution trace + auto instance = std::make_shared(builder, /*is_structured=*/true); + // builder.blocks.summarize(); + UltraProver prover(instance); + auto verification_key = std::make_shared(instance->proving_key); + UltraVerifier verifier(verification_key); + auto proof = prover.construct_proof(); + EXPECT_TRUE(verifier.verify_proof(proof)); +} + /** * @brief Test simple circuit with public inputs * From 518dfafc5ff60cde179d90b3128cbc8c519964d5 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Fri, 26 Apr 2024 16:28:12 +0000 Subject: [PATCH 2/7] tests for UH and UGH working --- .../arithmetization/arithmetization.hpp | 5 +- .../protogalaxy/protogalaxy.test.cpp | 18 +++++ .../ultra_honk/goblin_ultra_composer.test.cpp | 37 ++++++++++ .../ultra_honk/relation_correctness.test.cpp | 71 +++++++++++++++++++ .../ultra_honk/ultra_composer.test.cpp | 3 +- 5 files changed, 131 insertions(+), 3 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp index 8815928c473..ec80709dec5 100644 --- a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp +++ b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp @@ -119,7 +119,7 @@ template class UltraArith { public: static constexpr size_t NUM_WIRES = 4; static constexpr size_t NUM_SELECTORS = 11; - static constexpr size_t FIXED_BLOCK_SIZE = 5; // tiny for testing (5 * 6 = 30 < 2^5) + static constexpr size_t FIXED_BLOCK_SIZE = 1 << 10; // Size of each block in a structured trace using FF = FF_; class UltraTraceBlock : public ExecutionTraceBlock { @@ -197,7 +197,8 @@ template class UltraHonkArith { public: static constexpr size_t NUM_WIRES = 4; static constexpr size_t NUM_SELECTORS = 14; - static constexpr size_t FIXED_BLOCK_SIZE = 5; // tiny for testing (6 * 10 = 60 < 2^6) + static constexpr size_t FIXED_BLOCK_SIZE = 1 << 10; // Size of each block in a structured trace + using FF = FF_; class UltraHonkTraceBlock : public ExecutionTraceBlock { diff --git a/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp b/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp index bf72f4ca5eb..3fee8f1c1b7 100644 --- a/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp +++ b/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp @@ -314,6 +314,24 @@ template class ProtoGalaxyTests : public testing::Test { } } + /** + * @brief Testing two valid rounds of folding followed by the decider. + * + */ + static void test_full_structured_protogalaxy() + { + TupleOfInstances insts = construct_instances(2); + auto [prover_accumulator, verifier_accumulator] = fold_and_verify(get<0>(insts), get<1>(insts)); + check_accumulator_target_sum_manual(prover_accumulator, true); + + TupleOfInstances insts_2 = construct_instances(1); // just one set of prover/verifier instances + auto [prover_accumulator_2, verifier_accumulator_2] = + fold_and_verify({ prover_accumulator, get<0>(insts_2)[0] }, { verifier_accumulator, get<1>(insts_2)[0] }); + check_accumulator_target_sum_manual(prover_accumulator_2, true); + + decide_and_verify(prover_accumulator_2, verifier_accumulator_2, true); + } + /** * @brief Testing two valid rounds of folding followed by the decider. * 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 eabc2edbb27..6cbb636d947 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 @@ -34,6 +34,7 @@ class GoblinUltraHonkComposerTests : public ::testing::Test { bool construct_and_verify_honk_proof(auto& builder) { auto instance = std::make_shared>(builder); + // builder.blocks.summarize(); GoblinUltraProver prover(instance); auto verification_key = std::make_shared(instance->proving_key); GoblinUltraVerifier verifier(verification_key); @@ -59,6 +60,42 @@ class GoblinUltraHonkComposerTests : public ::testing::Test { }; } // namespace +/** + * @brief Test proof construction/verification for a circuit with ECC op gates, public inputs, and basic arithmetic + * gates + * + */ +TEST_F(GoblinUltraHonkComposerTests, Basic) +{ + GoblinUltraCircuitBuilder builder; + + GoblinMockCircuits::construct_simple_circuit(builder); + + // Construct and verify Honk proof + bool honk_verified = construct_and_verify_honk_proof(builder); + EXPECT_TRUE(honk_verified); +} + +/** + * @brief Test proof construction/verification for a structured execution trace + * + */ +TEST_F(GoblinUltraHonkComposerTests, BasicStructured) +{ + GoblinUltraCircuitBuilder builder; + + GoblinMockCircuits::construct_simple_circuit(builder); + + // Construct and verify Honk proof + auto instance = std::make_shared>(builder, /*is_structured=*/true); + builder.blocks.summarize(); + GoblinUltraProver prover(instance); + auto verification_key = std::make_shared(instance->proving_key); + GoblinUltraVerifier verifier(verification_key); + auto proof = prover.construct_proof(); + EXPECT_TRUE(verifier.verify_proof(proof)); +} + /** * @brief Test proof construction/verification for a circuit with ECC op gates, public inputs, and basic arithmetic * gates diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/relation_correctness.test.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/relation_correctness.test.cpp index ac3ca627ce5..5463f7f8eda 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/relation_correctness.test.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/relation_correctness.test.cpp @@ -357,6 +357,77 @@ TEST_F(UltraRelationCorrectnessTests, GoblinUltra) auto& prover_polynomials = instance->prover_polynomials; auto params = instance->relation_parameters; + // Check that each relation is satisfied across each row of the prover polynomials + check_relation>(circuit_size, prover_polynomials, params); + check_relation>(circuit_size, prover_polynomials, params); + check_relation>(circuit_size, prover_polynomials, params); + check_relation>(circuit_size, prover_polynomials, params); + check_relation>(circuit_size, prover_polynomials, params); + check_relation>(circuit_size, prover_polynomials, params); + check_relation>(circuit_size, prover_polynomials, params); + check_linearly_dependent_relation>( + circuit_size, prover_polynomials, params); +} + +TEST_F(UltraRelationCorrectnessTests, GoblinUltraStructured) +{ + using Flavor = GoblinUltraFlavor; + using FF = typename Flavor::FF; + + // Create a composer and then add an assortment of gates designed to ensure that the constraint(s) represented + // by each relation are non-trivially exercised. + auto builder = GoblinUltraCircuitBuilder(); + + // // Create an assortment of representative gates + // create_some_add_gates(builder); + // create_some_lookup_gates(builder); + // create_some_delta_range_constraint_gates(builder); + // create_some_elliptic_curve_addition_gates(builder); + // create_some_RAM_gates(builder); + // create_some_ecc_op_queue_gates(builder); // Goblin! + + // Create a prover (it will compute proving key and witness) + auto instance = std::make_shared>(builder, true); + builder.blocks.summarize(); + auto& proving_key = instance->proving_key; + auto circuit_size = proving_key.circuit_size; + + // Generate eta, beta and gamma + instance->relation_parameters.eta = FF::random_element(); + instance->relation_parameters.eta_two = FF::random_element(); + instance->relation_parameters.eta_three = FF::random_element(); + instance->relation_parameters.beta = FF::random_element(); + instance->relation_parameters.gamma = FF::random_element(); + + instance->proving_key.compute_sorted_accumulator_polynomials(instance->relation_parameters.eta, + instance->relation_parameters.eta_two, + instance->relation_parameters.eta_three); + instance->proving_key.compute_logderivative_inverse(instance->relation_parameters); + instance->proving_key.compute_grand_product_polynomials(instance->relation_parameters); + instance->prover_polynomials = Flavor::ProverPolynomials(instance->proving_key); + + // Check that selectors are nonzero to ensure corresponding relation has nontrivial contribution + ensure_non_zero(proving_key.q_arith); + ensure_non_zero(proving_key.q_delta_range); + ensure_non_zero(proving_key.q_lookup); + ensure_non_zero(proving_key.q_elliptic); + ensure_non_zero(proving_key.q_aux); + ensure_non_zero(proving_key.q_busread); + ensure_non_zero(proving_key.q_poseidon2_external); + ensure_non_zero(proving_key.q_poseidon2_internal); + + ensure_non_zero(proving_key.calldata); + ensure_non_zero(proving_key.calldata_read_counts); + ensure_non_zero(proving_key.calldata_inverses); + ensure_non_zero(proving_key.return_data); + ensure_non_zero(proving_key.return_data_read_counts); + ensure_non_zero(proving_key.return_data_inverses); + + // Construct the round for applying sumcheck relations and results for storing computed results + using Relations = typename Flavor::Relations; + auto& prover_polynomials = instance->prover_polynomials; + auto params = instance->relation_parameters; + // Check that each relation is satisfied across each row of the prover polynomials check_relation>(circuit_size, prover_polynomials, params); check_relation>(circuit_size, prover_polynomials, params); diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp index 600e55e8342..f5ca8c43cb8 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp @@ -92,7 +92,7 @@ TEST_F(UltraHonkComposerTests, ANonZeroPolynomialIsAGoodPolynomial) TEST_F(UltraHonkComposerTests, StructuredTrace) { auto builder = UltraCircuitBuilder(); - size_t num_gates = 1; + size_t num_gates = 3; // Add some arbitrary arithmetic gates that utilize public inputs for (size_t i = 0; i < num_gates; ++i) { @@ -112,6 +112,7 @@ TEST_F(UltraHonkComposerTests, StructuredTrace) // Construct an instance with a structured execution trace auto instance = std::make_shared(builder, /*is_structured=*/true); // builder.blocks.summarize(); + info(instance->proving_key.circuit_size); UltraProver prover(instance); auto verification_key = std::make_shared(instance->proving_key); UltraVerifier verifier(verification_key); From 19731c335ee6d0cedafc2bbc55965630bfa9733e Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Fri, 26 Apr 2024 18:16:14 +0000 Subject: [PATCH 3/7] tests for PG including inhomog --- .../src/barretenberg/goblin/mock_circuits.hpp | 11 +- .../arithmetization/arithmetization.hpp | 4 +- .../protogalaxy/protogalaxy.test.cpp | 112 ++++++++++++++---- .../stdlib_circuit_builders/mock_circuits.hpp | 67 ++++++++--- 4 files changed, 146 insertions(+), 48 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp index cb87096063e..e6457060f6f 100644 --- a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp +++ b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp @@ -116,7 +116,7 @@ class GoblinMockCircuits { * * @param builder */ - static void construct_simple_circuit(GoblinUltraBuilder& builder) + static void add_some_ecc_op_gates(GoblinUltraBuilder& builder) { // Add some arbitrary ecc op gates for (size_t i = 0; i < 3; ++i) { @@ -127,7 +127,16 @@ class GoblinMockCircuits { } // queues the result of the preceding ECC builder.queue_ecc_eq(); // should be eq and reset + } + /** + * @brief Generate a simple test circuit with some ECC op gates and conventional arithmetic gates + * + * @param builder + */ + static void construct_simple_circuit(GoblinUltraBuilder& builder) + { + add_some_ecc_op_gates(builder); MockCircuits::construct_arithmetic_circuit(builder); } diff --git a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp index ec80709dec5..33dec336843 100644 --- a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp +++ b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp @@ -166,7 +166,7 @@ template class UltraArith { auto get() { return RefArray{ pub_inputs, arithmetic, delta_range, elliptic, aux, lookup }; } - void summarize() + void summarize() const { info("Gate blocks summary:"); info("pub inputs:\t", pub_inputs.size()); @@ -282,7 +282,7 @@ template class UltraHonkArith { aux, lookup, busread, poseidon_external, poseidon_internal }; } - void summarize() + void summarize() const { info("Gate blocks summary:"); info("goblin ecc op:\t", ecc_op.size()); diff --git a/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp b/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp index 3fee8f1c1b7..1a4326cfc4b 100644 --- a/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp +++ b/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp @@ -4,6 +4,7 @@ #include "barretenberg/protogalaxy/decider_verifier.hpp" #include "barretenberg/protogalaxy/protogalaxy_prover.hpp" #include "barretenberg/protogalaxy/protogalaxy_verifier.hpp" +#include "barretenberg/stdlib_circuit_builders/mock_circuits.hpp" #include @@ -43,24 +44,29 @@ template class ProtoGalaxyTests : public testing::Test { static void construct_circuit(Builder& builder) { + MockCircuits::add_some_arithmetic_gates(builder); if constexpr (IsGoblinFlavor) { - GoblinMockCircuits::construct_simple_circuit(builder); - } else { - 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) }); + GoblinMockCircuits::add_some_ecc_op_gates(builder); } } + // Construct prover and verifier instance for a provided circuit and add to tuple + static void construct_prover_and_verifier_instance(TupleOfInstances& instances, + Builder& builder, + bool structured = false) + { + + auto prover_instance = std::make_shared(builder, structured); + builder.blocks.summarize(); + info(prover_instance->proving_key.circuit_size); + auto verification_key = std::make_shared(prover_instance->proving_key); + auto verifier_instance = std::make_shared(verification_key); + get<0>(instances).emplace_back(prover_instance); + get<1>(instances).emplace_back(verifier_instance); + } + // constructs num_insts number of prover and verifier instances - static TupleOfInstances construct_instances(size_t num_insts) + static TupleOfInstances construct_instances(size_t num_insts, bool structured = false) { TupleOfInstances instances; // TODO(https://github.com/AztecProtocol/barretenberg/issues/938): Parallelize this loop @@ -68,11 +74,7 @@ template class ProtoGalaxyTests : public testing::Test { auto builder = typename Flavor::CircuitBuilder(); construct_circuit(builder); - auto prover_instance = std::make_shared(builder); - auto verification_key = std::make_shared(prover_instance->proving_key); - auto verifier_instance = std::make_shared(verification_key); - get<0>(instances).emplace_back(prover_instance); - get<1>(instances).emplace_back(verifier_instance); + construct_prover_and_verifier_instance(instances, builder, structured); } return instances; } @@ -318,7 +320,7 @@ template class ProtoGalaxyTests : public testing::Test { * @brief Testing two valid rounds of folding followed by the decider. * */ - static void test_full_structured_protogalaxy() + static void test_full_protogalaxy() { TupleOfInstances insts = construct_instances(2); auto [prover_accumulator, verifier_accumulator] = fold_and_verify(get<0>(insts), get<1>(insts)); @@ -333,20 +335,69 @@ template class ProtoGalaxyTests : public testing::Test { } /** - * @brief Testing two valid rounds of folding followed by the decider. + * @brief Testing two valid rounds of folding followed by the decider for a structured trace. * */ - static void test_full_protogalaxy() + static void test_full_protogalaxy_structured_trace() { - TupleOfInstances insts = construct_instances(2); - auto [prover_accumulator, verifier_accumulator] = fold_and_verify(get<0>(insts), get<1>(insts)); + bool structured = true; + TupleOfInstances instances = construct_instances(2, structured); + + auto [prover_accumulator, verifier_accumulator] = fold_and_verify(get<0>(instances), get<1>(instances)); check_accumulator_target_sum_manual(prover_accumulator, true); - TupleOfInstances insts_2 = construct_instances(1); // just one set of prover/verifier instances - auto [prover_accumulator_2, verifier_accumulator_2] = - fold_and_verify({ prover_accumulator, get<0>(insts_2)[0] }, { verifier_accumulator, get<1>(insts_2)[0] }); + TupleOfInstances instances_2 = construct_instances(1, structured); // just one set of prover/verifier instances + + auto [prover_accumulator_2, verifier_accumulator_2] = fold_and_verify( + { prover_accumulator, get<0>(instances_2)[0] }, { verifier_accumulator, get<1>(instances_2)[0] }); + check_accumulator_target_sum_manual(prover_accumulator_2, true); + info(prover_accumulator_2->proving_key.circuit_size); + decide_and_verify(prover_accumulator_2, verifier_accumulator_2, true); + } + + /** + * @brief Testing two valid rounds of folding followed by the decider for a structured trace. + * @details Here we're interested in folding inhomogeneous circuits, i.e. circuits with different numbers of + * constraints, which should be automatically handled by the structured trace + * + */ + static void test_full_protogalaxy_structured_trace_inhomogeneous_circuits() + { + bool structured = true; + + // Construct three circuits to be folded, each with a different number of constraints + Builder builder1; + Builder builder2; + Builder builder3; + // Create inhomogenous circuits by calling the circuit gen function multiple times + construct_circuit(builder1); + for (size_t i = 0; i < 3; ++i) { + construct_circuit(builder2); + } + for (size_t i = 0; i < 20; ++i) { + construct_circuit(builder3); + } + + // Construct the Prover/Verifier instances for the first two circuits + TupleOfInstances instances; + construct_prover_and_verifier_instance(instances, builder1, structured); + construct_prover_and_verifier_instance(instances, builder2, structured); + + // Fold the first two instances + auto [prover_accumulator, verifier_accumulator] = fold_and_verify(get<0>(instances), get<1>(instances)); + check_accumulator_target_sum_manual(prover_accumulator, true); + + // Construct the Prover/Verifier instance for the third circuit + TupleOfInstances instances_2; + construct_prover_and_verifier_instance(instances_2, builder3, structured); + + // Fold 3rd instance into accumulator + auto [prover_accumulator_2, verifier_accumulator_2] = fold_and_verify( + { prover_accumulator, get<0>(instances_2)[0] }, { verifier_accumulator, get<1>(instances_2)[0] }); check_accumulator_target_sum_manual(prover_accumulator_2, true); + info(prover_accumulator_2->proving_key.circuit_size); + // Decide on final accumulator decide_and_verify(prover_accumulator_2, verifier_accumulator_2, true); } @@ -449,6 +500,15 @@ TYPED_TEST(ProtoGalaxyTests, FullProtogalaxyTest) TestFixture::test_full_protogalaxy(); } +TYPED_TEST(ProtoGalaxyTests, FullProtogalaxyStructuredTrace) +{ + TestFixture::test_full_protogalaxy_structured_trace(); +} +TYPED_TEST(ProtoGalaxyTests, FullProtogalaxyStructuredTraceInhomogeneous) +{ + TestFixture::test_full_protogalaxy_structured_trace_inhomogeneous_circuits(); +} + TYPED_TEST(ProtoGalaxyTests, TamperedCommitment) { TestFixture::test_tampered_commitment(); diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mock_circuits.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mock_circuits.hpp index cb523ce7186..7d58daee40e 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mock_circuits.hpp +++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mock_circuits.hpp @@ -10,20 +10,16 @@ class MockCircuits { using Point = Curve::AffineElement; /** - * @brief Populate a builder with a specified number of arithmetic gates; includes a PI + * @brief A simple method for adding arithmetic gates that can be called arbitrarily many times * * @param builder * @param num_gates */ template - static void construct_arithmetic_circuit(Builder& builder, const size_t target_log2_dyadic_size = 4) + static void add_some_arithmetic_gates_with_public_inputs(Builder& builder, const size_t num_gates = 4) { - const size_t target_dyadic_size = 1 << target_log2_dyadic_size; - const size_t num_preamble_gates = builder.num_gates; - ASSERT(target_dyadic_size >= num_preamble_gates); - // For good measure, include a gate with some public inputs - if (target_dyadic_size > num_preamble_gates) { + for (size_t i = 0; i < num_gates; ++i) { FF a = FF::random_element(); FF b = FF::random_element(); FF c = FF::random_element(); @@ -35,6 +31,48 @@ class MockCircuits { builder.create_big_add_gate({ a_idx, b_idx, c_idx, d_idx, FF(1), FF(1), FF(1), FF(-1), FF(0) }); } + } + + /** + * @brief A simple method for adding arithmetic gates that can be called arbitrarily many times + * + * @param builder + * @param num_gates + */ + template static void add_some_arithmetic_gates(Builder& builder, const size_t num_gates = 4) + { + // For good measure, include a gate with some public inputs + for (size_t i = 0; i < num_gates; ++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_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) }); + } + } + + /** + * @brief Populate a builder with a specified number of arithmetic gates; includes a PI + * + * @param builder + * @param num_gates + */ + template + static void construct_arithmetic_circuit(Builder& builder, const size_t target_log2_dyadic_size = 4) + { + const size_t target_dyadic_size = 1 << target_log2_dyadic_size; + const size_t num_preamble_gates = builder.num_gates; + ASSERT(target_dyadic_size >= num_preamble_gates); + + // For good measure, include a gate with some public inputs + if (target_dyadic_size > num_preamble_gates) { + add_some_arithmetic_gates_with_public_inputs(builder, 1); + } // A proper treatment of this would dynamically calculate how many gates to add given static information about // Builder, but a major overhaul of the execution trace is underway, so we just elect to use a hack. Namely, for @@ -46,19 +84,10 @@ class MockCircuits { // to prevent underflow of the loop upper limit; target size >= 16 should suffice ASSERT(target_dyadic_size > OFFSET_HACK + num_preamble_gates); - // Add arbitrary arithmetic gates to obtain a total of num_gates-many gates - 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_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); + size_t num_gates_to_add = target_dyadic_size - OFFSET_HACK - 1 - num_preamble_gates; - for (size_t i = 0; i < target_dyadic_size - OFFSET_HACK - 1 - num_preamble_gates; ++i) { - builder.create_big_add_gate({ a_idx, b_idx, c_idx, d_idx, FF(1), FF(1), FF(1), FF(-1), FF(0) }); - } + // Add arbitrary arithmetic gates to obtain a total of num_gates-many gates + add_some_arithmetic_gates(builder, num_gates_to_add); } /** From 3518868ce272af199ddc434528abc801d5042072 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Fri, 26 Apr 2024 18:33:26 +0000 Subject: [PATCH 4/7] cleanup --- .../protogalaxy/protogalaxy.test.cpp | 4 +-- .../stdlib_circuit_builders/mock_circuits.hpp | 12 ++++---- .../ultra_honk/goblin_ultra_composer.test.cpp | 5 ++-- .../ultra_honk/ultra_composer.test.cpp | 29 ++----------------- 4 files changed, 13 insertions(+), 37 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp b/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp index 1a4326cfc4b..954f5186099 100644 --- a/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp +++ b/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp @@ -44,7 +44,7 @@ template class ProtoGalaxyTests : public testing::Test { static void construct_circuit(Builder& builder) { - MockCircuits::add_some_arithmetic_gates(builder); + MockCircuits::add_arithmetic_gates(builder); if constexpr (IsGoblinFlavor) { GoblinMockCircuits::add_some_ecc_op_gates(builder); } @@ -57,8 +57,6 @@ template class ProtoGalaxyTests : public testing::Test { { auto prover_instance = std::make_shared(builder, structured); - builder.blocks.summarize(); - info(prover_instance->proving_key.circuit_size); auto verification_key = std::make_shared(prover_instance->proving_key); auto verifier_instance = std::make_shared(verification_key); get<0>(instances).emplace_back(prover_instance); diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mock_circuits.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mock_circuits.hpp index 7d58daee40e..36937d8c347 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mock_circuits.hpp +++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mock_circuits.hpp @@ -10,13 +10,13 @@ class MockCircuits { using Point = Curve::AffineElement; /** - * @brief A simple method for adding arithmetic gates that can be called arbitrarily many times + * @brief Add a specified number of arithmetic gates (with public inputs) to the provided circuit * * @param builder * @param num_gates */ template - static void add_some_arithmetic_gates_with_public_inputs(Builder& builder, const size_t num_gates = 4) + static void add_arithmetic_gates_with_public_inputs(Builder& builder, const size_t num_gates = 4) { // For good measure, include a gate with some public inputs for (size_t i = 0; i < num_gates; ++i) { @@ -34,12 +34,12 @@ class MockCircuits { } /** - * @brief A simple method for adding arithmetic gates that can be called arbitrarily many times + * @brief Add a specified number of arithmetic gates to the provided circuit * * @param builder * @param num_gates */ - template static void add_some_arithmetic_gates(Builder& builder, const size_t num_gates = 4) + template static void add_arithmetic_gates(Builder& builder, const size_t num_gates = 4) { // For good measure, include a gate with some public inputs for (size_t i = 0; i < num_gates; ++i) { @@ -71,7 +71,7 @@ class MockCircuits { // For good measure, include a gate with some public inputs if (target_dyadic_size > num_preamble_gates) { - add_some_arithmetic_gates_with_public_inputs(builder, 1); + add_arithmetic_gates_with_public_inputs(builder, 1); } // A proper treatment of this would dynamically calculate how many gates to add given static information about @@ -87,7 +87,7 @@ class MockCircuits { size_t num_gates_to_add = target_dyadic_size - OFFSET_HACK - 1 - num_preamble_gates; // Add arbitrary arithmetic gates to obtain a total of num_gates-many gates - add_some_arithmetic_gates(builder, num_gates_to_add); + add_arithmetic_gates(builder, num_gates_to_add); } /** 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 6cbb636d947..beb35bf213b 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 @@ -86,8 +86,9 @@ TEST_F(GoblinUltraHonkComposerTests, BasicStructured) GoblinMockCircuits::construct_simple_circuit(builder); - // Construct and verify Honk proof - auto instance = std::make_shared>(builder, /*is_structured=*/true); + // Construct and verify Honk proof using a structured trace + bool structured = true; + auto instance = std::make_shared>(builder, structured); builder.blocks.summarize(); GoblinUltraProver prover(instance); auto verification_key = std::make_shared(instance->proving_key); diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp index f5ca8c43cb8..ca27fcf752b 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp @@ -4,6 +4,7 @@ #include "barretenberg/plonk_honk_shared/library/grand_product_delta.hpp" #include "barretenberg/relations/permutation_relation.hpp" #include "barretenberg/relations/relation_parameters.hpp" +#include "barretenberg/stdlib_circuit_builders/mock_circuits.hpp" #include "barretenberg/stdlib_circuit_builders/plookup_tables/fixed_base/fixed_base.hpp" #include "barretenberg/stdlib_circuit_builders/plookup_tables/types.hpp" #include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp" @@ -95,19 +96,7 @@ TEST_F(UltraHonkComposerTests, StructuredTrace) size_t num_gates = 3; // Add some arbitrary arithmetic gates that utilize public inputs - for (size_t i = 0; i < num_gates; ++i) { - fr a = fr::random_element(); - uint32_t a_idx = builder.add_public_variable(a); - - fr b = fr::random_element(); - fr c = fr::random_element(); - fr d = a + b + c; - 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, fr(1), fr(1), fr(1), fr(-1), fr(0) }); - } + MockCircuits::add_arithmetic_gates_with_public_inputs(builder, num_gates); // Construct an instance with a structured execution trace auto instance = std::make_shared(builder, /*is_structured=*/true); @@ -130,19 +119,7 @@ TEST_F(UltraHonkComposerTests, PublicInputs) size_t num_gates = 10; // Add some arbitrary arithmetic gates that utilize public inputs - for (size_t i = 0; i < num_gates; ++i) { - fr a = fr::random_element(); - uint32_t a_idx = builder.add_public_variable(a); - - fr b = fr::random_element(); - fr c = fr::random_element(); - fr d = a + b + c; - 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, fr(1), fr(1), fr(1), fr(-1), fr(0) }); - } + MockCircuits::add_arithmetic_gates_with_public_inputs(builder, num_gates); prove_and_verify(builder, /*expected_result=*/true); } From de1a8866d64b1c4df47b98f1d0cad7c958f203ea Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Fri, 26 Apr 2024 18:34:02 +0000 Subject: [PATCH 5/7] remove correctness test --- .../ultra_honk/relation_correctness.test.cpp | 71 ------------------- 1 file changed, 71 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/relation_correctness.test.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/relation_correctness.test.cpp index 5463f7f8eda..ac3ca627ce5 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/relation_correctness.test.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/relation_correctness.test.cpp @@ -357,77 +357,6 @@ TEST_F(UltraRelationCorrectnessTests, GoblinUltra) auto& prover_polynomials = instance->prover_polynomials; auto params = instance->relation_parameters; - // Check that each relation is satisfied across each row of the prover polynomials - check_relation>(circuit_size, prover_polynomials, params); - check_relation>(circuit_size, prover_polynomials, params); - check_relation>(circuit_size, prover_polynomials, params); - check_relation>(circuit_size, prover_polynomials, params); - check_relation>(circuit_size, prover_polynomials, params); - check_relation>(circuit_size, prover_polynomials, params); - check_relation>(circuit_size, prover_polynomials, params); - check_linearly_dependent_relation>( - circuit_size, prover_polynomials, params); -} - -TEST_F(UltraRelationCorrectnessTests, GoblinUltraStructured) -{ - using Flavor = GoblinUltraFlavor; - using FF = typename Flavor::FF; - - // Create a composer and then add an assortment of gates designed to ensure that the constraint(s) represented - // by each relation are non-trivially exercised. - auto builder = GoblinUltraCircuitBuilder(); - - // // Create an assortment of representative gates - // create_some_add_gates(builder); - // create_some_lookup_gates(builder); - // create_some_delta_range_constraint_gates(builder); - // create_some_elliptic_curve_addition_gates(builder); - // create_some_RAM_gates(builder); - // create_some_ecc_op_queue_gates(builder); // Goblin! - - // Create a prover (it will compute proving key and witness) - auto instance = std::make_shared>(builder, true); - builder.blocks.summarize(); - auto& proving_key = instance->proving_key; - auto circuit_size = proving_key.circuit_size; - - // Generate eta, beta and gamma - instance->relation_parameters.eta = FF::random_element(); - instance->relation_parameters.eta_two = FF::random_element(); - instance->relation_parameters.eta_three = FF::random_element(); - instance->relation_parameters.beta = FF::random_element(); - instance->relation_parameters.gamma = FF::random_element(); - - instance->proving_key.compute_sorted_accumulator_polynomials(instance->relation_parameters.eta, - instance->relation_parameters.eta_two, - instance->relation_parameters.eta_three); - instance->proving_key.compute_logderivative_inverse(instance->relation_parameters); - instance->proving_key.compute_grand_product_polynomials(instance->relation_parameters); - instance->prover_polynomials = Flavor::ProverPolynomials(instance->proving_key); - - // Check that selectors are nonzero to ensure corresponding relation has nontrivial contribution - ensure_non_zero(proving_key.q_arith); - ensure_non_zero(proving_key.q_delta_range); - ensure_non_zero(proving_key.q_lookup); - ensure_non_zero(proving_key.q_elliptic); - ensure_non_zero(proving_key.q_aux); - ensure_non_zero(proving_key.q_busread); - ensure_non_zero(proving_key.q_poseidon2_external); - ensure_non_zero(proving_key.q_poseidon2_internal); - - ensure_non_zero(proving_key.calldata); - ensure_non_zero(proving_key.calldata_read_counts); - ensure_non_zero(proving_key.calldata_inverses); - ensure_non_zero(proving_key.return_data); - ensure_non_zero(proving_key.return_data_read_counts); - ensure_non_zero(proving_key.return_data_inverses); - - // Construct the round for applying sumcheck relations and results for storing computed results - using Relations = typename Flavor::Relations; - auto& prover_polynomials = instance->prover_polynomials; - auto params = instance->relation_parameters; - // Check that each relation is satisfied across each row of the prover polynomials check_relation>(circuit_size, prover_polynomials, params); check_relation>(circuit_size, prover_polynomials, params); From 328d3b927dececc5cdd3a887fe261c8579895e61 Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Fri, 26 Apr 2024 18:50:00 +0000 Subject: [PATCH 6/7] clarify todo --- .../src/barretenberg/sumcheck/instance/prover_instance.hpp | 3 ++- .../barretenberg/ultra_honk/goblin_ultra_composer.test.cpp | 1 - .../cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/sumcheck/instance/prover_instance.hpp b/barretenberg/cpp/src/barretenberg/sumcheck/instance/prover_instance.hpp index a25cf6bf30b..60c055f6125 100644 --- a/barretenberg/cpp/src/barretenberg/sumcheck/instance/prover_instance.hpp +++ b/barretenberg/cpp/src/barretenberg/sumcheck/instance/prover_instance.hpp @@ -55,7 +55,8 @@ template class ProverInstance_ { } // TODO(https://github.com/AztecProtocol/barretenberg/issues/905): This is adding ops to the op queue but NOT to - // the circuit, meaning the ECCVM/Translator will use different ops than the main circuit / merge protocol. + // the circuit, meaning the ECCVM/Translator will use different ops than the main circuit. This will lead to + // failure once https://github.com/AztecProtocol/barretenberg/issues/746 is resolved. if constexpr (IsGoblinFlavor) { circuit.op_queue->append_nonzero_ops(); } 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 beb35bf213b..dc5f8e76dc0 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 @@ -34,7 +34,6 @@ class GoblinUltraHonkComposerTests : public ::testing::Test { bool construct_and_verify_honk_proof(auto& builder) { auto instance = std::make_shared>(builder); - // builder.blocks.summarize(); GoblinUltraProver prover(instance); auto verification_key = std::make_shared(instance->proving_key); GoblinUltraVerifier verifier(verification_key); diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp index ca27fcf752b..a4d5cf5e5d8 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_composer.test.cpp @@ -99,8 +99,8 @@ TEST_F(UltraHonkComposerTests, StructuredTrace) MockCircuits::add_arithmetic_gates_with_public_inputs(builder, num_gates); // Construct an instance with a structured execution trace - auto instance = std::make_shared(builder, /*is_structured=*/true); - // builder.blocks.summarize(); + bool structured = true; + auto instance = std::make_shared(builder, structured); info(instance->proving_key.circuit_size); UltraProver prover(instance); auto verification_key = std::make_shared(instance->proving_key); From 39d91fa0196e7e254f1d1886b74f5a27521dbc7e Mon Sep 17 00:00:00 2001 From: ledwards2225 Date: Fri, 26 Apr 2024 20:29:51 +0000 Subject: [PATCH 7/7] improve comments and clarity in response to review --- .../execution_trace/execution_trace.hpp | 5 +++++ .../arithmetization/arithmetization.hpp | 4 ++-- .../barretenberg/protogalaxy/protogalaxy.test.cpp | 14 +++++++------- 3 files changed, 14 insertions(+), 9 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.hpp b/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.hpp index 08115e052fc..ddbc4babffe 100644 --- a/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/execution_trace/execution_trace.hpp @@ -39,6 +39,11 @@ template class ExecutionTrace_ { /** * @brief Given a circuit, populate a proving key with wire polys, selector polys, and sigma/id polys + * @note By default, this method constructs an exectution trace that is sorted by gate type. Optionally, it + * constructs a trace that is both sorted and "structured" in the sense that each block/gate-type has a fixed amount + * of space within the wire polynomials, regardless of how many actual constraints of each type exist. This is + * useful primarily for folding since it guarantees that the set of relations that must be executed at each row is + * consistent across all instances. * * @param builder * @param is_structured whether or not the trace is to be structured with a fixed block size diff --git a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp index 33dec336843..c864af55e7c 100644 --- a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp +++ b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/arithmetization.hpp @@ -119,7 +119,7 @@ template class UltraArith { public: static constexpr size_t NUM_WIRES = 4; static constexpr size_t NUM_SELECTORS = 11; - static constexpr size_t FIXED_BLOCK_SIZE = 1 << 10; // Size of each block in a structured trace + static constexpr size_t FIXED_BLOCK_SIZE = 1 << 10; // Size of each block in a structured trace (arbitrary for now) using FF = FF_; class UltraTraceBlock : public ExecutionTraceBlock { @@ -197,7 +197,7 @@ template class UltraHonkArith { public: static constexpr size_t NUM_WIRES = 4; static constexpr size_t NUM_SELECTORS = 14; - static constexpr size_t FIXED_BLOCK_SIZE = 1 << 10; // Size of each block in a structured trace + static constexpr size_t FIXED_BLOCK_SIZE = 1 << 10; // Size of each block in a structured trace (arbitrary for now) using FF = FF_; diff --git a/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp b/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp index 954f5186099..2443df21615 100644 --- a/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp +++ b/barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp @@ -367,14 +367,14 @@ template class ProtoGalaxyTests : public testing::Test { Builder builder1; Builder builder2; Builder builder3; - // Create inhomogenous circuits by calling the circuit gen function multiple times construct_circuit(builder1); - for (size_t i = 0; i < 3; ++i) { - construct_circuit(builder2); - } - for (size_t i = 0; i < 20; ++i) { - construct_circuit(builder3); - } + construct_circuit(builder2); + construct_circuit(builder3); + + // Create inhomogenous circuits by adding a different number of add gates to each + MockCircuits::add_arithmetic_gates(builder1, 10); + MockCircuits::add_arithmetic_gates(builder2, 100); + MockCircuits::add_arithmetic_gates(builder3, 1000); // Construct the Prover/Verifier instances for the first two circuits TupleOfInstances instances;