refactor: Deduplication in Protogalaxy (#8067)

Share some code between prover and verifier, and unify some code paths
in the prover where we had duplication between zero-optimized and
general cases.

barretenberg/cpp/.clangd

@@ -65,6 +65,8 @@ Diagnostics:
       - cert-dc21-cpp
       # Noisy. As we don't need to return error types or raw allocations, really unlikely we'd cause problems by ignoring a return type.
       - modernize-use-nodiscard
+      # Misleading; linker error fixed by adding const in declaration
+      - readability-avoid-const-params-in-decls
 
 --- # this divider is necessary
 # Disable some checks for Google Test/Bench

barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy.test.cpp

@@ -2,6 +2,7 @@
 #include "barretenberg/polynomials/pow.hpp"
 #include "barretenberg/protogalaxy/protogalaxy_prover.hpp"
 #include "barretenberg/protogalaxy/protogalaxy_verifier.hpp"
+#include "barretenberg/protogalaxy/prover_verifier_shared.hpp"
 #include "barretenberg/stdlib_circuit_builders/mock_circuits.hpp"
 #include "barretenberg/ultra_honk/decider_prover.hpp"
 #include "barretenberg/ultra_honk/decider_verifier.hpp"
@@ -218,7 +219,7 @@ template <typename Flavor> class ProtoGalaxyTests : public testing::Test {
         accumulator->relation_parameters = relation_parameters;
         accumulator->alphas = alphas;
 
-        auto deltas = ProtoGalaxyProver::compute_round_challenge_pows(log_instance_size, FF::random_element());
+        auto deltas = compute_round_challenge_pows(log_instance_size, FF::random_element());
         auto perturbator = ProtoGalaxyProver::compute_perturbator(accumulator, deltas);
 
         // Ensure the constant coefficient of the perturbator is equal to the target sum as indicated by the paper

barretenberg/cpp/src/barretenberg/protogalaxy/protogalaxy_prover_impl.hpp

@@ -3,8 +3,10 @@
 #include "barretenberg/common/op_count.hpp"
 #include "barretenberg/common/thread.hpp"
 #include "barretenberg/flavor/flavor.hpp"
+#include "barretenberg/protogalaxy/prover_verifier_shared.hpp"
 #include "barretenberg/ultra_honk/oink_prover.hpp"
 #include "protogalaxy_prover.hpp"
+
 namespace bb {
 // See protogalaxy_prover.hpp for details
 template <class ProverInstances_>
@@ -361,21 +363,6 @@ template <class ProverInstances> void ProtoGalaxyProver_<ProverInstances>::pertu
     }
 };
 
-template <class ProverInstances_>
-std::vector<typename bb::ProtoGalaxyProver_<ProverInstances_>::FF> bb::ProtoGalaxyProver_<
-    ProverInstances_>::update_gate_challenges(const FF perturbator_challenge,
-                                              const std::vector<FF>& gate_challenges,
-                                              const std::vector<FF>& round_challenges)
-{
-    auto log_instance_size = gate_challenges.size();
-    std::vector<FF> next_gate_challenges(log_instance_size);
-
-    for (size_t idx = 0; idx < log_instance_size; idx++) {
-        next_gate_challenges[idx] = gate_challenges[idx] + perturbator_challenge * round_challenges[idx];
-    }
-    return next_gate_challenges;
-}
-
 template <class ProverInstances> void ProtoGalaxyProver_<ProverInstances>::combiner_quotient_round()
 {
     BB_OP_COUNT_TIME_NAME("ProtoGalaxyProver_::combiner_quotient_round");

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

@@ -1,6 +1,8 @@
 #include "protogalaxy_verifier.hpp"
 #include "barretenberg/plonk_honk_shared/library/grand_product_delta.hpp"
+#include "barretenberg/protogalaxy/prover_verifier_shared.hpp"
 #include "barretenberg/ultra_honk/oink_verifier.hpp"
+
 namespace bb {
 
 template <class VerifierInstances>

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

@@ -30,32 +30,6 @@ template <class VerifierInstances> class ProtoGalaxyVerifier_ {
     ProtoGalaxyVerifier_(const std::vector<std::shared_ptr<Instance>>& insts)
         : instances(VerifierInstances(insts)){};
     ~ProtoGalaxyVerifier_() = default;
-    /**
-     * @brief Given a new round challenge δ for each iteration of the full ProtoGalaxy protocol, compute the vector
-     * [δ, δ^2,..., δ^t] where t = logn and n is the size of the instance.
-     */
-    static std::vector<FF> compute_round_challenge_pows(size_t log_instance_size, FF round_challenge)
-    {
-        std::vector<FF> pows(log_instance_size);
-        pows[0] = round_challenge;
-        for (size_t i = 1; i < log_instance_size; i++) {
-            pows[i] = pows[i - 1].sqr();
-        }
-        return pows;
-    }
-
-    static std::vector<FF> update_gate_challenges(const FF perturbator_challenge,
-                                                  const std::vector<FF>& gate_challenges,
-                                                  const std::vector<FF>& round_challenges)
-    {
-        auto log_instance_size = gate_challenges.size();
-        std::vector<FF> next_gate_challenges(log_instance_size);
-
-        for (size_t idx = 0; idx < log_instance_size; idx++) {
-            next_gate_challenges[idx] = gate_challenges[idx] + perturbator_challenge * round_challenges[idx];
-        }
-        return next_gate_challenges;
-    }
 
     std::shared_ptr<Instance> get_accumulator() { return instances[0]; }
 

barretenberg/cpp/src/barretenberg/protogalaxy/prover_verifier_shared.cpp

@@ -0,0 +1,31 @@
+#include "barretenberg/protogalaxy/prover_verifier_shared.hpp"
+
+namespace bb {
+std::vector<fr> update_gate_challenges(const fr perturbator_challenge,
+                                       const std::vector<fr>& gate_challenges,
+                                       const std::vector<fr>& round_challenges)
+{
+    auto log_instance_size = gate_challenges.size();
+    std::vector<fr> next_gate_challenges(log_instance_size);
+
+    for (size_t idx = 0; idx < log_instance_size; idx++) {
+        next_gate_challenges[idx] = gate_challenges[idx] + perturbator_challenge * round_challenges[idx];
+    }
+    return next_gate_challenges;
+}
+
+/**
+ * @brief For a new round challenge δ at each iteration of the ProtoGalaxy protocol, compute the vector
+ * [δ, δ^2,..., δ^t] where t = logn and n is the size of the instance.
+ */
+std::vector<fr> compute_round_challenge_pows(const size_t log_instance_size, const fr& round_challenge)
+{
+    std::vector<fr> pows(log_instance_size);
+    pows[0] = round_challenge;
+    for (size_t i = 1; i < log_instance_size; i++) {
+        pows[i] = pows[i - 1].sqr();
+    }
+    return pows;
+}
+
+} // namespace bb

barretenberg/cpp/src/barretenberg/protogalaxy/prover_verifier_shared.hpp

@@ -0,0 +1,20 @@
+#pragma once
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include <vector>
+
+namespace bb {
+/**
+ * @brief Compute the gate challenges used int the combiner calculation.
+ * @details This is Step 8 of the protocol as written in the paper.
+ */
+std::vector<fr> update_gate_challenges(const fr perturbator_challenge,
+                                       const std::vector<fr>& gate_challenges,
+                                       const std::vector<fr>& round_challenges);
+
+/**
+ * @brief For a new round challenge δ at each iteration of the ProtoGalaxy protocol, compute the vector
+ * [δ, δ^2,..., δ^t] where t = logn and n is the size of the instance.
+ */
+std::vector<fr> compute_round_challenge_pows(const size_t log_instance_size, const fr& round_challenge);
+
+} // namespace bb