refactor: share code between provers

barretenberg/cpp/src/barretenberg/benchmark/ultra_bench/ultra_honk_rounds.bench.cpp

@@ -45,11 +45,12 @@ BB_PROFILE static void test_round_inner(State& state, GoblinUltraProver& prover,
         }
     };
 
-    time_if_index(PREAMBLE, [&] { prover.execute_preamble_round(); });
-    time_if_index(WIRE_COMMITMENTS, [&] { prover.execute_wire_commitments_round(); });
-    time_if_index(SORTED_LIST_ACCUMULATOR, [&] { prover.execute_sorted_list_accumulator_round(); });
-    time_if_index(LOG_DERIVATIVE_INVERSE, [&] { prover.execute_log_derivative_inverse_round(); });
-    time_if_index(GRAND_PRODUCT_COMPUTATION, [&] { prover.execute_grand_product_computation_round(); });
+    time_if_index(PREAMBLE, [&] { prover.pre_sumcheck_prover.execute_preamble_round(); });
+    time_if_index(WIRE_COMMITMENTS, [&] { prover.pre_sumcheck_prover.execute_wire_commitments_round(); });
+    time_if_index(SORTED_LIST_ACCUMULATOR, [&] { prover.pre_sumcheck_prover.execute_sorted_list_accumulator_round(); });
+    time_if_index(LOG_DERIVATIVE_INVERSE, [&] { prover.pre_sumcheck_prover.execute_log_derivative_inverse_round(); });
+    time_if_index(GRAND_PRODUCT_COMPUTATION,
+                  [&] { prover.pre_sumcheck_prover.execute_grand_product_computation_round(); });
     time_if_index(RELATION_CHECK, [&] { prover.execute_relation_check_rounds(); });
     time_if_index(ZEROMORPH, [&] { prover.execute_zeromorph_rounds(); });
 }
@@ -63,7 +64,10 @@ BB_PROFILE static void test_round(State& state, size_t index) noexcept
     GoblinUltraProver prover = bb::mock_proofs::get_prover(
         composer, &bb::mock_proofs::generate_basic_arithmetic_circuit<GoblinUltraCircuitBuilder>, log2_num_gates);
     for (auto _ : state) {
+        state.PauseTiming();
         test_round_inner(state, prover, index);
+        state.ResumeTiming();
+        // NOTE: google bench is very finnicky, must end in ResumeTiming() for correctness
     }
 }
 #define ROUND_BENCHMARK(round)                                                                                         \

barretenberg/cpp/src/barretenberg/protogalaxy/presumcheck_prover.cpp

@@ -0,0 +1,135 @@
+#include "barretenberg/protogalaxy/presumcheck_prover.hpp"
+
+namespace bb {
+
+/**
+ * @brief Add circuit size, public input size, and public inputs to transcript
+ *
+ */
+template <IsUltraFlavor Flavor> void PreSumcheckProver<Flavor>::execute_preamble_round()
+{
+    const auto instance_size = static_cast<uint32_t>(instance->instance_size);
+    const auto num_public_inputs = static_cast<uint32_t>(instance->public_inputs.size());
+    transcript->send_to_verifier(domain_separator + "instance_size", instance_size);
+    transcript->send_to_verifier(domain_separator + "public_input_size", num_public_inputs);
+    transcript->send_to_verifier(domain_separator + "pub_inputs_offset",
+                                 static_cast<uint32_t>(instance->pub_inputs_offset));
+
+    ASSERT(instance->proving_key->num_public_inputs == instance->public_inputs.size());
+
+    for (size_t i = 0; i < instance->public_inputs.size(); ++i) {
+        auto public_input_i = instance->public_inputs[i];
+        transcript->send_to_verifier(domain_separator + "public_input_" + std::to_string(i), public_input_i);
+    }
+}
+
+/**
+ * @brief Commit to the wire polynomials (part of the witness), with the exception of the fourth wire, which is
+ * only commited to after adding memory records. In the Goblin Flavor, we also commit to the ECC OP wires and the
+ * DataBus columns.
+ */
+template <IsUltraFlavor Flavor> void PreSumcheckProver<Flavor>::execute_wire_commitments_round()
+{
+    auto& witness_commitments = instance->witness_commitments;
+
+    // Commit to the first three wire polynomials of the instance
+    // We only commit to the fourth wire polynomial after adding memory recordss
+    witness_commitments.w_l = commitment_key->commit(instance->proving_key->w_l);
+    witness_commitments.w_r = commitment_key->commit(instance->proving_key->w_r);
+    witness_commitments.w_o = commitment_key->commit(instance->proving_key->w_o);
+
+    auto wire_comms = witness_commitments.get_wires();
+    auto commitment_labels = instance->commitment_labels;
+    auto wire_labels = commitment_labels.get_wires();
+    for (size_t idx = 0; idx < 3; ++idx) {
+        transcript->send_to_verifier(domain_separator + wire_labels[idx], wire_comms[idx]);
+    }
+
+    if constexpr (IsGoblinFlavor<Flavor>) {
+        // Commit to Goblin ECC op wires
+        witness_commitments.ecc_op_wire_1 = commitment_key->commit(instance->proving_key->ecc_op_wire_1);
+        witness_commitments.ecc_op_wire_2 = commitment_key->commit(instance->proving_key->ecc_op_wire_2);
+        witness_commitments.ecc_op_wire_3 = commitment_key->commit(instance->proving_key->ecc_op_wire_3);
+        witness_commitments.ecc_op_wire_4 = commitment_key->commit(instance->proving_key->ecc_op_wire_4);
+
+        auto op_wire_comms = instance->witness_commitments.get_ecc_op_wires();
+        auto labels = commitment_labels.get_ecc_op_wires();
+        for (size_t idx = 0; idx < Flavor::NUM_WIRES; ++idx) {
+            transcript->send_to_verifier(domain_separator + labels[idx], op_wire_comms[idx]);
+        }
+        // Commit to DataBus columns
+        witness_commitments.calldata = commitment_key->commit(instance->proving_key->calldata);
+        witness_commitments.calldata_read_counts = commitment_key->commit(instance->proving_key->calldata_read_counts);
+        transcript->send_to_verifier(domain_separator + commitment_labels.calldata,
+                                     instance->witness_commitments.calldata);
+        transcript->send_to_verifier(domain_separator + commitment_labels.calldata_read_counts,
+                                     instance->witness_commitments.calldata_read_counts);
+    }
+}
+
+/**
+ * @brief Compute sorted witness-table accumulator and commit to the resulting polynomials.
+ *
+ */
+template <IsUltraFlavor Flavor> void PreSumcheckProver<Flavor>::execute_sorted_list_accumulator_round()
+{
+    auto& witness_commitments = instance->witness_commitments;
+    const auto& commitment_labels = instance->commitment_labels;
+
+    auto eta = transcript->template get_challenge<typename Flavor::FF>(domain_separator + "eta");
+    instance->compute_sorted_accumulator_polynomials(eta);
+
+    // Commit to the sorted witness-table accumulator and the finalized (i.e. with memory records) fourth wire
+    // polynomial
+    witness_commitments.sorted_accum = commitment_key->commit(instance->prover_polynomials.sorted_accum);
+    witness_commitments.w_4 = commitment_key->commit(instance->prover_polynomials.w_4);
+
+    transcript->send_to_verifier(domain_separator + commitment_labels.sorted_accum, witness_commitments.sorted_accum);
+    transcript->send_to_verifier(domain_separator + commitment_labels.w_4, witness_commitments.w_4);
+}
+
+/**
+ * @brief Compute log derivative inverse polynomial and its commitment, if required
+ *
+ */
+template <IsUltraFlavor Flavor> void PreSumcheckProver<Flavor>::execute_log_derivative_inverse_round()
+{
+    const auto& commitment_labels = instance->commitment_labels;
+
+    auto [beta, gamma] =
+        transcript->template get_challenges<typename Flavor::FF>(domain_separator + "beta", domain_separator + "gamma");
+    instance->relation_parameters.beta = beta;
+    instance->relation_parameters.gamma = gamma;
+    if constexpr (IsGoblinFlavor<Flavor>) {
+        // Compute and commit to the logderivative inverse used in DataBus
+        instance->compute_logderivative_inverse(beta, gamma);
+        instance->witness_commitments.lookup_inverses =
+            commitment_key->commit(instance->prover_polynomials.lookup_inverses);
+        transcript->send_to_verifier(domain_separator + commitment_labels.lookup_inverses,
+                                     instance->witness_commitments.lookup_inverses);
+    }
+}
+
+/**
+ * @brief Compute permutation and lookup grand product polynomials and their commitments
+ *
+ */
+template <IsUltraFlavor Flavor> void PreSumcheckProver<Flavor>::execute_grand_product_computation_round()
+{
+    auto& witness_commitments = instance->witness_commitments;
+    const auto& commitment_labels = instance->commitment_labels;
+
+    instance->compute_grand_product_polynomials(instance->relation_parameters.beta,
+                                                instance->relation_parameters.gamma);
+
+    witness_commitments.z_perm = commitment_key->commit(instance->prover_polynomials.z_perm);
+    witness_commitments.z_lookup = commitment_key->commit(instance->prover_polynomials.z_lookup);
+
+    transcript->send_to_verifier(domain_separator + commitment_labels.z_perm, instance->witness_commitments.z_perm);
+    transcript->send_to_verifier(domain_separator + commitment_labels.z_lookup, instance->witness_commitments.z_lookup);
+}
+
+template class PreSumcheckProver<UltraFlavor>;
+template class PreSumcheckProver<GoblinUltraFlavor>;
+
+} // namespace bb

barretenberg/cpp/src/barretenberg/protogalaxy/presumcheck_prover.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#include <utility>
+
+#include "barretenberg/flavor/goblin_ultra.hpp"
+#include "barretenberg/flavor/ultra.hpp"
+#include "barretenberg/sumcheck/instance/prover_instance.hpp"
+#include "barretenberg/transcript/transcript.hpp"
+
+namespace bb {
+
+template <IsUltraFlavor Flavor> class PreSumcheckProver {
+    using CommitmentKey = typename Flavor::CommitmentKey;
+    using Instance = ProverInstance_<Flavor>;
+    using Transcript = typename Flavor::Transcript;
+
+  public:
+    PreSumcheckProver(const std::shared_ptr<ProverInstance_<Flavor>>& inst,
+                      const std::shared_ptr<typename Flavor::CommitmentKey>& commitment_key,
+                      const std::shared_ptr<typename Flavor::Transcript>& transcript,
+                      std::string domain_separator = "")
+        : instance(inst)
+        , transcript(transcript)
+        , commitment_key(commitment_key)
+        , domain_separator(std::move(domain_separator))
+    {
+        instance->initialize_prover_polynomials();
+    }
+
+    void execute_preamble_round();
+
+    void execute_wire_commitments_round();
+
+    void execute_sorted_list_accumulator_round();
+
+    void execute_log_derivative_inverse_round();
+
+    void execute_grand_product_computation_round();
+
+    std::shared_ptr<Instance> instance;
+    std::shared_ptr<Transcript> transcript;
+    std::shared_ptr<CommitmentKey> commitment_key;
+    std::string domain_separator;
+};
+
+template <IsUltraFlavor Flavor>
+void prover_setup_(const std::shared_ptr<ProverInstance_<Flavor>>& instance,
+                   const std::shared_ptr<typename Flavor::CommitmentKey>& commitment_key,
+                   const std::shared_ptr<typename Flavor::Transcript>& transcript,
+                   const std::string& domain_separator = "");
+} // namespace bb

barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy_prover.cpp

@@ -1,94 +1,18 @@
 #include "protogalaxy_prover.hpp"
 #include "barretenberg/flavor/flavor.hpp"
+#include "barretenberg/protogalaxy/presumcheck_prover.hpp"
 namespace bb {
 template <class ProverInstances>
 void ProtoGalaxyProver_<ProverInstances>::finalise_and_send_instance(std::shared_ptr<Instance> instance,
                                                                      const std::string& domain_separator)
 {
-    instance->initialize_prover_polynomials();
-
-    const auto instance_size = static_cast<uint32_t>(instance->instance_size);
-    const auto num_public_inputs = static_cast<uint32_t>(instance->public_inputs.size());
-    transcript->send_to_verifier(domain_separator + "_instance_size", instance_size);
-    transcript->send_to_verifier(domain_separator + "_public_input_size", num_public_inputs);
-
-    for (size_t i = 0; i < instance->public_inputs.size(); ++i) {
-        auto public_input_i = instance->public_inputs[i];
-        transcript->send_to_verifier(domain_separator + "_public_input_" + std::to_string(i), public_input_i);
-    }
-    transcript->send_to_verifier(domain_separator + "_pub_inputs_offset",
-                                 static_cast<uint32_t>(instance->pub_inputs_offset));
-
-    auto& witness_commitments = instance->witness_commitments;
-
-    // Commit to the first three wire polynomials of the instance
-    // We only commit to the fourth wire polynomial after adding memory recordss
-    witness_commitments.w_l = commitment_key->commit(instance->proving_key->w_l);
-    witness_commitments.w_r = commitment_key->commit(instance->proving_key->w_r);
-    witness_commitments.w_o = commitment_key->commit(instance->proving_key->w_o);
-
-    auto wire_comms = witness_commitments.get_wires();
-    auto commitment_labels = instance->commitment_labels;
-    auto wire_labels = commitment_labels.get_wires();
-    for (size_t idx = 0; idx < 3; ++idx) {
-        transcript->send_to_verifier(domain_separator + "_" + wire_labels[idx], wire_comms[idx]);
-    }
-
-    if constexpr (IsGoblinFlavor<Flavor>) {
-        // Commit to Goblin ECC op wires
-        witness_commitments.ecc_op_wire_1 = commitment_key->commit(instance->proving_key->ecc_op_wire_1);
-        witness_commitments.ecc_op_wire_2 = commitment_key->commit(instance->proving_key->ecc_op_wire_2);
-        witness_commitments.ecc_op_wire_3 = commitment_key->commit(instance->proving_key->ecc_op_wire_3);
-        witness_commitments.ecc_op_wire_4 = commitment_key->commit(instance->proving_key->ecc_op_wire_4);
-
-        auto op_wire_comms = instance->witness_commitments.get_ecc_op_wires();
-        auto labels = commitment_labels.get_ecc_op_wires();
-        for (size_t idx = 0; idx < Flavor::NUM_WIRES; ++idx) {
-            transcript->send_to_verifier(domain_separator + "_" + labels[idx], op_wire_comms[idx]);
-        }
-        // Commit to DataBus columns
-        witness_commitments.calldata = commitment_key->commit(instance->proving_key->calldata);
-        witness_commitments.calldata_read_counts = commitment_key->commit(instance->proving_key->calldata_read_counts);
-        transcript->send_to_verifier(domain_separator + "_" + commitment_labels.calldata,
-                                     instance->witness_commitments.calldata);
-        transcript->send_to_verifier(domain_separator + "_" + commitment_labels.calldata_read_counts,
-                                     instance->witness_commitments.calldata_read_counts);
-    }
-
-    auto eta = transcript->template get_challenge<FF>(domain_separator + "_eta");
-    instance->compute_sorted_accumulator_polynomials(eta);
-
-    // Commit to the sorted witness-table accumulator and the finalized (i.e. with memory records) fourth wire
-    // polynomial
-    witness_commitments.sorted_accum = commitment_key->commit(instance->prover_polynomials.sorted_accum);
-    witness_commitments.w_4 = commitment_key->commit(instance->prover_polynomials.w_4);
-
-    transcript->send_to_verifier(domain_separator + "_" + commitment_labels.sorted_accum,
-                                 witness_commitments.sorted_accum);
-    transcript->send_to_verifier(domain_separator + "_" + commitment_labels.w_4, witness_commitments.w_4);
-
-    auto [beta, gamma] =
-        transcript->template get_challenges<FF>(domain_separator + "_beta", domain_separator + "_gamma");
-
-    if constexpr (IsGoblinFlavor<Flavor>) {
-        // Compute and commit to the logderivative inverse used in DataBus
-        instance->compute_logderivative_inverse(beta, gamma);
-        instance->witness_commitments.lookup_inverses =
-            commitment_key->commit(instance->prover_polynomials.lookup_inverses);
-        transcript->send_to_verifier(domain_separator + "_" + commitment_labels.lookup_inverses,
-                                     instance->witness_commitments.lookup_inverses);
-    }
-
-    instance->compute_grand_product_polynomials(beta, gamma);
-
-    witness_commitments.z_perm = commitment_key->commit(instance->prover_polynomials.z_perm);
-    witness_commitments.z_lookup = commitment_key->commit(instance->prover_polynomials.z_lookup);
-
-    transcript->send_to_verifier(domain_separator + "_" + commitment_labels.z_perm,
-                                 instance->witness_commitments.z_perm);
-    transcript->send_to_verifier(domain_separator + "_" + commitment_labels.z_lookup,
-                                 instance->witness_commitments.z_lookup);
-    for (size_t idx = 0; idx < NUM_SUBRELATIONS - 1; idx++) {
+    PreSumcheckProver<Flavor> pre_sumcheck_prover(instance, commitment_key, transcript, domain_separator + '_');
+    pre_sumcheck_prover.execute_preamble_round();
+    pre_sumcheck_prover.execute_wire_commitments_round();
+    pre_sumcheck_prover.execute_sorted_list_accumulator_round();
+    pre_sumcheck_prover.execute_log_derivative_inverse_round();
+    pre_sumcheck_prover.execute_grand_product_computation_round();
+    for (size_t idx = 0; idx < Flavor::NUM_SUBRELATIONS - 1; idx++) {
         instance->alphas[idx] =
             transcript->template get_challenge<FF>(domain_separator + "_alpha_" + std::to_string(idx));
     }

barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy_verifier.cpp

@@ -70,16 +70,15 @@ void ProtoGalaxyVerifier_<VerifierInstances>::receive_and_finalise_instance(cons
     inst->log_instance_size = static_cast<size_t>(numeric::get_msb(inst->instance_size));
     inst->public_input_size =
         transcript->template receive_from_prover<uint32_t>(domain_separator + "_public_input_size");
+    inst->pub_inputs_offset =
+        transcript->template receive_from_prover<uint32_t>(domain_separator + "_pub_inputs_offset");
 
     for (size_t i = 0; i < inst->public_input_size; ++i) {
         auto public_input_i =
             transcript->template receive_from_prover<FF>(domain_separator + "_public_input_" + std::to_string(i));
         inst->public_inputs.emplace_back(public_input_i);
     }
 
-    inst->pub_inputs_offset =
-        transcript->template receive_from_prover<uint32_t>(domain_separator + "_pub_inputs_offset");
-
     // Get commitments to first three wire polynomials
     auto labels = inst->commitment_labels;
     auto& witness_commitments = inst->witness_commitments;

barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/protogalaxy_recursive_verifier.cpp

@@ -75,18 +75,17 @@ void ProtoGalaxyRecursiveVerifier_<VerifierInstances>::receive_and_finalise_inst
     inst->instance_size = uint32_t(instance_size.get_value());
     inst->log_instance_size = static_cast<size_t>(numeric::get_msb(inst->instance_size));
     inst->public_input_size = uint32_t(public_input_size.get_value());
+    const auto pub_inputs_offset =
+        transcript->template receive_from_prover<FF>(domain_separator + "_pub_inputs_offset");
+
+    inst->pub_inputs_offset = uint32_t(pub_inputs_offset.get_value());
 
     for (size_t i = 0; i < inst->public_input_size; ++i) {
         auto public_input_i =
             transcript->template receive_from_prover<FF>(domain_separator + "_public_input_" + std::to_string(i));
         inst->public_inputs.emplace_back(public_input_i);
     }
 
-    const auto pub_inputs_offset =
-        transcript->template receive_from_prover<FF>(domain_separator + "_pub_inputs_offset");
-
-    inst->pub_inputs_offset = uint32_t(pub_inputs_offset.get_value());
-
     // Get commitments to first three wire polynomials
     auto labels = inst->commitment_labels;
     auto& witness_commitments = inst->witness_commitments;

barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/ultra_recursive_verifier.cpp

@@ -36,7 +36,7 @@ std::array<typename Flavor::GroupElement, 2> UltraRecursiveVerifier_<Flavor>::ve
     VerifierCommitments commitments{ key };
     CommitmentLabels commitment_labels;
 
-    const auto circuit_size = transcript->template receive_from_prover<FF>("circuit_size");
+    const auto circuit_size = transcript->template receive_from_prover<FF>("instance_size");
     const auto public_input_size = transcript->template receive_from_prover<FF>("public_input_size");
     const auto pub_inputs_offset = transcript->template receive_from_prover<FF>("pub_inputs_offset");
 

barretenberg/cpp/src/barretenberg/ultra_honk/goblin_ultra_transcript.test.cpp

@@ -42,7 +42,7 @@ class GoblinUltraTranscriptTests : public ::testing::Test {
         size_t frs_per_uint32 = bb::field_conversion::calc_num_bn254_frs<uint32_t>();
 
         size_t round = 0;
-        manifest_expected.add_entry(round, "circuit_size", frs_per_uint32);
+        manifest_expected.add_entry(round, "instance_size", frs_per_uint32);
         manifest_expected.add_entry(round, "public_input_size", frs_per_uint32);
         manifest_expected.add_entry(round, "pub_inputs_offset", frs_per_uint32);
         manifest_expected.add_entry(round, "public_input_0", frs_per_Fr);