feat: Protogalaxy Combiner

barretenberg/cpp/src/barretenberg/benchmark/relations_bench/barycentric.bench.cpp

@@ -1,5 +1,5 @@
-#include "barretenberg/polynomials/barycentric.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include <benchmark/benchmark.h>
 
 using namespace benchmark;
@@ -17,9 +17,8 @@ namespace proof_system::benchmark {
 void extend_2_to_6(State& state) noexcept
 {
     auto univariate = Univariate<FF, 2>::get_random();
-    BarycentricData<FF, 2, 6> barycentric_2_to_6;
     for (auto _ : state) {
-        DoNotOptimize(barycentric_2_to_6.extend(univariate));
+        DoNotOptimize(univariate.extend_to<6>());
     }
 }
 BENCHMARK(extend_2_to_6);

barretenberg/cpp/src/barretenberg/benchmark/relations_bench/relations.bench.cpp

@@ -19,24 +19,15 @@ using FF = barretenberg::fr;
 
 template <typename Flavor, typename Relation> void execute_relation(::benchmark::State& state)
 {
-    // Generate beta and gamma
-    auto beta = FF::random_element();
-    auto gamma = FF::random_element();
-    auto public_input_delta = FF::random_element();
-
-    RelationParameters<FF> params{
-        .beta = beta,
-        .gamma = gamma,
-        .public_input_delta = public_input_delta,
-    };
-
     using AllValues = typename Flavor::AllValues;
-    using ArrayOfValuesOverSubrelations = typename Relation::ArrayOfValuesOverSubrelations;
+    using SumcheckArrayOfValuesOverSubrelations = typename Relation::SumcheckArrayOfValuesOverSubrelations;
+
+    auto params = proof_system::RelationParameters<FF>::get_random();
 
     // Extract an array containing all the polynomial evaluations at a given row i
     AllValues new_value;
-    // Define the appropriate ArrayOfValuesOverSubrelations type for this relation and initialize to zero
-    ArrayOfValuesOverSubrelations accumulator;
+    // Define the appropriate SumcheckArrayOfValuesOverSubrelations type for this relation and initialize to zero
+    SumcheckArrayOfValuesOverSubrelations accumulator;
     // Evaluate each constraint in the relation and check that each is satisfied
 
     for (auto _ : state) {

barretenberg/cpp/src/barretenberg/honk/flavor/ecc_vm.hpp

@@ -76,8 +76,8 @@ template <typename CycleGroup_T, typename Curve_T, typename PCS_T> class ECCVMBa
     // static_assert(instantiate_barycentric_utils<FF, MAX_RANDOM_RELATION_LENGTH>());
 
     // define the containers for storing the contributions from each relation in Sumcheck
-    using TupleOfTuplesOfUnivariates = decltype(create_relation_univariates_container<FF, Relations>());
-    using TupleOfArraysOfValues = decltype(create_relation_values_container<FF, Relations>());
+    using SumcheckTupleOfTuplesOfUnivariates = decltype(create_sumcheck_tuple_of_tuples_of_univariates<Relations>());
+    using TupleOfArraysOfValues = decltype(create_sumcheck_tuple_of_arrays_of_values<Relations>());
 
   private:
     /**
@@ -712,13 +712,16 @@ template <typename CycleGroup_T, typename Curve_T, typename PCS_T> class ECCVMBa
         }
     };
 
+    /**
+     * @brief A container for univariates used during sumcheck.
+     */
+    template <size_t LENGTH>
+    using ProverUnivariates = AllEntities<barretenberg::Univariate<FF, LENGTH>, barretenberg::Univariate<FF, LENGTH>>;
+
     /**
      * @brief A container for univariates produced during the hot loop in sumcheck.
-     * @todo TODO(#390): Simplify this by moving MAX_RELATION_LENGTH?
      */
-    template <size_t MAX_RELATION_LENGTH>
-    using ExtendedEdges = AllEntities<barretenberg::Univariate<FF, MAX_RELATION_LENGTH>,
-                                      barretenberg::Univariate<FF, MAX_RELATION_LENGTH>>;
+    using ExtendedEdges = ProverUnivariates<MAX_RELATION_LENGTH>;
 
     /**
      * @brief A container for the prover polynomials handles; only stores spans.

barretenberg/cpp/src/barretenberg/honk/flavor/flavor.test.cpp

@@ -33,7 +33,6 @@ TEST(Flavor, Getters)
 
     Flavor::VerificationKey verification_key;
     Flavor::ProverPolynomials prover_polynomials;
-    Flavor::ExtendedEdges<Flavor::NUM_ALL_ENTITIES> edges;
     Flavor::AllValues evals;
     Flavor::CommitmentLabels commitment_labels;
 

barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra.hpp

@@ -58,9 +58,11 @@ class GoblinUltra {
     static constexpr size_t MAX_RANDOM_RELATION_LENGTH = MAX_RELATION_LENGTH + 1;
     static constexpr size_t NUM_RELATIONS = std::tuple_size<Relations>::value;
 
-    // define the container for storing the univariate contribution from each relation in Sumcheck
-    using TupleOfTuplesOfUnivariates = decltype(create_relation_univariates_container<FF, Relations>());
-    using TupleOfArraysOfValues = decltype(create_relation_values_container<FF, Relations>());
+    template <size_t NUM_INSTANCES>
+    using ProtogalaxyTupleOfTuplesOfUnivariates =
+        decltype(create_protogalaxy_tuple_of_tuples_of_univariates<Relations, NUM_INSTANCES>());
+    using SumcheckTupleOfTuplesOfUnivariates = decltype(create_sumcheck_tuple_of_tuples_of_univariates<Relations>());
+    using TupleOfArraysOfValues = decltype(create_sumcheck_tuple_of_arrays_of_values<Relations>());
 
     // Whether or not the first row of the execution trace is reserved for 0s to enable shifts
     static constexpr bool has_zero_row = true;
@@ -318,13 +320,17 @@ class GoblinUltra {
         }
     };
 
+    /**
+     * @brief A container for univariates used during Protogalaxy folding and sumcheck.
+     * @details During folding and sumcheck, the prover evaluates the relations on these univariates.
+     */
+    template <size_t LENGTH>
+    using ProverUnivariates = AllEntities<barretenberg::Univariate<FF, LENGTH>, barretenberg::Univariate<FF, LENGTH>>;
+
     /**
      * @brief A container for univariates produced during the hot loop in sumcheck.
-     * @todo TODO(#390): Simplify this by moving MAX_RELATION_LENGTH?
      */
-    template <size_t MAX_RELATION_LENGTH>
-    using ExtendedEdges = AllEntities<barretenberg::Univariate<FF, MAX_RELATION_LENGTH>,
-                                      barretenberg::Univariate<FF, MAX_RELATION_LENGTH>>;
+    using ExtendedEdges = ProverUnivariates<MAX_RELATION_LENGTH>;
 
     /**
      * @brief A field element for each entity of the flavor. These entities represent the prover polynomials evaluated

barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra_recursive.hpp

@@ -85,8 +85,8 @@ template <typename BuilderType> class GoblinUltraRecursive_ {
     static constexpr size_t NUM_RELATIONS = std::tuple_size<Relations>::value;
 
     // define the container for storing the univariate contribution from each relation in Sumcheck
-    using TupleOfTuplesOfUnivariates = decltype(create_relation_univariates_container<FF, Relations>());
-    using TupleOfArraysOfValues = decltype(create_relation_values_container<FF, Relations>());
+    using SumcheckTupleOfTuplesOfUnivariates = decltype(create_sumcheck_tuple_of_tuples_of_univariates<Relations>());
+    using TupleOfArraysOfValues = decltype(create_sumcheck_tuple_of_arrays_of_values<Relations>());
 
   private:
     template <typename DataType, typename HandleType>

barretenberg/cpp/src/barretenberg/honk/flavor/ultra.hpp

@@ -60,9 +60,11 @@ class Ultra {
     static constexpr size_t MAX_RANDOM_RELATION_LENGTH = MAX_RELATION_LENGTH + 1;
     static constexpr size_t NUM_RELATIONS = std::tuple_size<Relations>::value;
 
-    // define the container for storing the univariate contribution from each relation in Sumcheck
-    using TupleOfTuplesOfUnivariates = decltype(create_relation_univariates_container<FF, Relations>());
-    using TupleOfArraysOfValues = decltype(create_relation_values_container<FF, Relations>());
+    template <size_t NUM_INSTANCES>
+    using ProtogalaxyTupleOfTuplesOfUnivariates =
+        decltype(create_protogalaxy_tuple_of_tuples_of_univariates<Relations, NUM_INSTANCES>());
+    using SumcheckTupleOfTuplesOfUnivariates = decltype(create_sumcheck_tuple_of_tuples_of_univariates<Relations>());
+    using TupleOfArraysOfValues = decltype(create_sumcheck_tuple_of_arrays_of_values<Relations>());
 
     // Whether or not the first row of the execution trace is reserved for 0s to enable shifts
     static constexpr bool has_zero_row = true;
@@ -315,13 +317,17 @@ class Ultra {
         }
     };
 
+    /**
+     * @brief A container for univariates used during Protogalaxy folding and sumcheck.
+     * @details During folding and sumcheck, the prover evaluates the relations on these univariates.
+     */
+    template <size_t LENGTH>
+    using ProverUnivariates = AllEntities<barretenberg::Univariate<FF, LENGTH>, barretenberg::Univariate<FF, LENGTH>>;
+
     /**
      * @brief A container for univariates produced during the hot loop in sumcheck.
-     * @todo TODO(#390): Simplify this by moving MAX_RELATION_LENGTH?
      */
-    template <size_t MAX_RELATION_LENGTH>
-    using ExtendedEdges = AllEntities<barretenberg::Univariate<FF, MAX_RELATION_LENGTH>,
-                                      barretenberg::Univariate<FF, MAX_RELATION_LENGTH>>;
+    using ExtendedEdges = ProverUnivariates<MAX_RELATION_LENGTH>;
 
     /**
      * @brief A container for commitment labels.

barretenberg/cpp/src/barretenberg/honk/flavor/ultra_recursive.hpp

@@ -36,7 +36,7 @@ namespace proof_system::honk::flavor {
  * @details This flavor can be used to instantiate a recursive Ultra Honk verifier for a proof created using the
  * conventional Ultra flavor. It is similar in structure to its native counterpart with two main differences: 1) the
  * curve types are stdlib types (e.g. field_t instead of field) and 2) it does not specify any Prover related types
- * (e.g. Polynomial, ExtendedEdges, etc.) since we do not emulate prover computation in circuits, i.e. it only makes
+ * (e.g. Polynomial, ProverUnivariates, etc.) since we do not emulate prover computation in circuits, i.e. it only makes
  * sense to instantiate a Verifier with this flavor.
  *
  * @note Unlike conventional flavors, "recursive" flavors are templated by a builder (much like native vs stdlib types).
@@ -84,8 +84,8 @@ template <typename BuilderType> class UltraRecursive_ {
     static constexpr size_t NUM_RELATIONS = std::tuple_size<Relations>::value;
 
     // define the container for storing the univariate contribution from each relation in Sumcheck
-    using TupleOfTuplesOfUnivariates = decltype(create_relation_univariates_container<FF, Relations>());
-    using TupleOfArraysOfValues = decltype(create_relation_values_container<FF, Relations>());
+    using SumcheckTupleOfTuplesOfUnivariates = decltype(create_sumcheck_tuple_of_tuples_of_univariates<Relations>());
+    using TupleOfArraysOfValues = decltype(create_sumcheck_tuple_of_arrays_of_values<Relations>());
 
   private:
     template <typename DataType, typename HandleType>

barretenberg/cpp/src/barretenberg/honk/instance/instances.hpp

@@ -5,6 +5,7 @@ namespace proof_system::honk {
 
 template <typename Flavor_, size_t NUM_> struct ProverInstances_ {
     using Flavor = Flavor_;
+    using FF = typename Flavor::FF;
     using Instance = ProverInstance_<Flavor>;
     using ArrayType = std::array<std::shared_ptr<Instance>, NUM_>;
 
@@ -14,13 +15,44 @@ template <typename Flavor_, size_t NUM_> struct ProverInstances_ {
     std::shared_ptr<Instance> const& operator[](size_t idx) const { return _data[idx]; }
     typename ArrayType::iterator begin() { return _data.begin(); };
     typename ArrayType::iterator end() { return _data.end(); };
+    ProverInstances_() = default;
     ProverInstances_(std::vector<std::shared_ptr<Instance>> data)
     {
         ASSERT(data.size() == NUM);
         for (size_t idx = 0; idx < data.size(); idx++) {
             _data[idx] = std::move(data[idx]);
         }
     };
+
+    /**
+     * @brief  For a prover polynomial label and a fixed row index, construct a uninvariate from the corresponding value
+     * from each instance.
+     *
+     * @example if the prover polynomia index is 1 and the row index is 2, and there are 4 instances visually we have
+     *
+     *           Instance 0       Instance 1       Instance 2       Instance 3
+     *           q_c q_l q_r ...  q_c q_l q_r ...  q_c q_l q_r ...  q_c q_l q_r ...
+     *           *   *            *   *            *   *            *   *
+     *           *   *            *   *            *   *            *   *
+     *           *   a            *   b            *   c            *   d
+     *           *   *            *   *            *   *            *   *
+     *
+     * and the function returns the univariate {a, b, c, d}
+     *
+     * @param entity_idx A fixed column position in several execution traces.
+     * @param row_idx A fixed row position in several execution
+     * @return Univariate<FF, NUM> The univariate whose extensions will be used to construct the combiner.
+     */
+    Univariate<FF, NUM> row_to_univariate(const size_t prover_polynomial_idx, const size_t row_idx) const
+    {
+        Univariate<FF, NUM> result;
+        size_t instance_idx = 0;
+        for (auto& instance : _data) {
+            result.evaluations[instance_idx] = instance->prover_polynomials._data[prover_polynomial_idx][row_idx];
+            instance_idx++;
+        }
+        return result;
+    }
 };
 
 template <typename Flavor_, size_t NUM_> struct VerifierInstances_ {

barretenberg/cpp/src/barretenberg/honk/instance/prover_instance.hpp

@@ -16,7 +16,7 @@ namespace proof_system::honk {
  *
  */
 // TODO(https://github.com/AztecProtocol/barretenberg/issues/725): create an Instances class that manages several
-// Instance and passes them to ProtoGakaxy prover and verifier so that Instance objects don't need to mantain an index
+// Instance and passes them to ProtoGalaxy prover and verifier so that Instance objects don't need to mantain an index
 template <class Flavor> class ProverInstance_ {
     using Circuit = typename Flavor::CircuitBuilder;
     using ProvingKey = typename Flavor::ProvingKey;
@@ -59,6 +59,7 @@ template <class Flavor> class ProverInstance_ {
         , public_inputs(result.folded_public_inputs)
         , folding_parameters(result.folding_parameters){};
 
+    ProverInstance_() = default;
     ~ProverInstance_() = default;
 
     std::shared_ptr<VerificationKey> compute_verification_key();