refactor: clean out prover instance and remove instance from oink

barretenberg/cpp/src/barretenberg/flavor/flavor.hpp

@@ -109,6 +109,7 @@ class ProvingKey_ : public PrecomputedPolynomials, public WitnessPolynomials {
     std::vector<uint32_t> recursive_proof_public_input_indices;
     bb::EvaluationDomain<FF> evaluation_domain;
     std::shared_ptr<CommitmentKey_> commitment_key;
+    std::array<Polynomial, 4> sorted_polynomials;
 
     // offset due to placing zero wires at the start of execution trace
     // non-zero  for Instances constructed from circuits, this concept doesn't exist for accumulated

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

@@ -6,6 +6,8 @@
 #include "barretenberg/honk/proof_system/types/proof.hpp"
 #include "barretenberg/polynomials/univariate.hpp"
 #include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp"
+#include "barretenberg/proof_system/library/grand_product_delta.hpp"
+#include "barretenberg/proof_system/library/grand_product_library.hpp"
 #include "barretenberg/relations/auxiliary_relation.hpp"
 #include "barretenberg/relations/databus_lookup_relation.hpp"
 #include "barretenberg/relations/ecc_op_queue_relation.hpp"
@@ -276,6 +278,121 @@ class GoblinUltraFlavor {
         };
         // The plookup wires that store plookup read data.
         auto get_table_column_wires() { return RefArray{ w_l, w_r, w_o }; };
+
+        /**
+         * @brief Construct sorted list accumulator polynomial 's'.
+         *
+         * @details Compute s = s_1 + η*s_2 + η²*s_3 + η³*s_4 (via Horner) where s_i are the
+         * sorted concatenated witness/table polynomials
+         *
+         * @param key proving key
+         * @param sorted_list_polynomials sorted concatenated witness/table polynomials
+         * @param eta random challenge
+         * @return Polynomial
+         */
+        void compute_sorted_list_accumulator(FF eta)
+        {
+            const size_t circuit_size = this->circuit_size;
+
+            auto sorted_list_accumulator = Polynomial{ circuit_size };
+
+            // Construct s via Horner, i.e. s = s_1 + η(s_2 + η(s_3 + η*s_4))
+            for (size_t i = 0; i < circuit_size; ++i) {
+                FF T0 = this->sorted_polynomials[3][i];
+                T0 *= eta;
+                T0 += this->sorted_polynomials[2][i];
+                T0 *= eta;
+                T0 += this->sorted_polynomials[1][i];
+                T0 *= eta;
+                T0 += this->sorted_polynomials[0][i];
+                sorted_list_accumulator[i] = T0;
+            }
+            this->sorted_accum = sorted_list_accumulator.share();
+        }
+
+        void compute_sorted_accumulator_polynomials(FF eta)
+        {
+            // Compute sorted witness-table accumulator
+            this->compute_sorted_list_accumulator(eta);
+
+            // Finalize fourth wire polynomial by adding lookup memory records
+            add_plookup_memory_records_to_wire_4(eta);
+        }
+
+        /**
+         * @brief Add plookup memory records to the fourth wire polynomial
+         *
+         * @details This operation must be performed after the first three wires have been committed to, hence the
+         * dependence on the `eta` challenge.
+         *
+         * @tparam Flavor
+         * @param eta challenge produced after commitment to first three wire polynomials
+         */
+        void add_plookup_memory_records_to_wire_4(FF eta)
+        {
+            // The plookup memory record values are computed at the indicated indices as
+            // w4 = w3 * eta^3 + w2 * eta^2 + w1 * eta + read_write_flag;
+            // (See plookup_auxiliary_widget.hpp for details)
+            auto wires = this->get_wires();
+
+            // Compute read record values
+            for (const auto& gate_idx : this->memory_read_records) {
+                wires[3][gate_idx] += wires[2][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += wires[1][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += wires[0][gate_idx];
+                wires[3][gate_idx] *= eta;
+            }
+
+            // Compute write record values
+            for (const auto& gate_idx : this->memory_write_records) {
+                wires[3][gate_idx] += wires[2][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += wires[1][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += wires[0][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += 1;
+            }
+        }
+
+        /**
+         * @brief Compute the inverse polynomial used in the log derivative lookup argument
+         *
+         * @tparam Flavor
+         * @param beta
+         * @param gamma
+         */
+        void compute_logderivative_inverse(RelationParameters<FF>& relation_parameters)
+        {
+            auto proving_key_ptr = std::make_shared<ProvingKey>(*this);
+            auto prover_polynomials = ProverPolynomials(proving_key_ptr);
+            // Compute permutation and lookup grand product polynomials
+            bb::compute_logderivative_inverse<GoblinUltraFlavor, typename GoblinUltraFlavor::LogDerivLookupRelation>(
+                prover_polynomials, relation_parameters, this->circuit_size);
+            this->lookup_inverses = prover_polynomials.lookup_inverses;
+        }
+
+        void compute_grand_product_polynomials(RelationParameters<FF>& relation_parameters)
+        {
+            auto public_input_delta = compute_public_input_delta<GoblinUltraFlavor>(this->public_inputs,
+                                                                                    relation_parameters.beta,
+                                                                                    relation_parameters.gamma,
+                                                                                    this->circuit_size,
+                                                                                    this->pub_inputs_offset);
+            relation_parameters.public_input_delta = public_input_delta;
+            auto lookup_grand_product_delta = compute_lookup_grand_product_delta(
+                relation_parameters.beta, relation_parameters.gamma, this->circuit_size);
+            relation_parameters.lookup_grand_product_delta = lookup_grand_product_delta;
+
+            // Compute permutation and lookup grand product polynomials
+            auto proving_key_ptr = std::make_shared<ProvingKey>(*this);
+            auto prover_polynomials = ProverPolynomials(proving_key_ptr);
+            compute_grand_products<GoblinUltraFlavor>(proving_key_ptr, prover_polynomials, relation_parameters);
+            this->z_perm = prover_polynomials.z_perm;
+            this->z_lookup = prover_polynomials.z_lookup;
+        }
     };
 
     /**
@@ -331,6 +448,17 @@ class GoblinUltraFlavor {
      */
     class ProverPolynomials : public AllEntities<Polynomial> {
       public:
+        ProverPolynomials(std::shared_ptr<ProvingKey>& proving_key)
+        {
+            for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key->get_all())) {
+                ASSERT(flavor_get_label(*this, prover_poly) == flavor_get_label(*proving_key, key_poly));
+                prover_poly = key_poly.share();
+            }
+            for (auto [prover_poly, key_poly] : zip_view(this->get_shifted(), proving_key->get_to_be_shifted())) {
+                ASSERT(flavor_get_label(*this, prover_poly) == (flavor_get_label(*proving_key, key_poly) + "_shift"));
+                prover_poly = key_poly.shifted();
+            }
+        }
         // Define all operations as default, except move construction/assignment
         ProverPolynomials() = default;
         ProverPolynomials& operator=(const ProverPolynomials&) = delete;

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

@@ -8,11 +8,14 @@
 #include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/polynomials/univariate.hpp"
 #include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp"
+#include "barretenberg/proof_system/library/grand_product_delta.hpp"
+#include "barretenberg/proof_system/library/grand_product_library.hpp"
 #include "barretenberg/relations/auxiliary_relation.hpp"
 #include "barretenberg/relations/elliptic_relation.hpp"
 #include "barretenberg/relations/gen_perm_sort_relation.hpp"
 #include "barretenberg/relations/lookup_relation.hpp"
 #include "barretenberg/relations/permutation_relation.hpp"
+#include "barretenberg/relations/relation_parameters.hpp"
 #include "barretenberg/relations/ultra_arithmetic_relation.hpp"
 #include "barretenberg/transcript/transcript.hpp"
 
@@ -280,6 +283,104 @@ class UltraFlavor {
         };
         // The plookup wires that store plookup read data.
         auto get_table_column_wires() { return RefArray{ w_l, w_r, w_o }; };
+
+        /**
+         * @brief Construct sorted list accumulator polynomial 's'.
+         *
+         * @details Compute s = s_1 + η*s_2 + η²*s_3 + η³*s_4 (via Horner) where s_i are the
+         * sorted concatenated witness/table polynomials
+         *
+         * @param key proving key
+         * @param sorted_list_polynomials sorted concatenated witness/table polynomials
+         * @param eta random challenge
+         * @return Polynomial
+         */
+        void compute_sorted_list_accumulator(FF eta)
+        {
+            const size_t circuit_size = this->circuit_size;
+
+            auto sorted_list_accumulator = Polynomial{ circuit_size };
+
+            // Construct s via Horner, i.e. s = s_1 + η(s_2 + η(s_3 + η*s_4))
+            for (size_t i = 0; i < circuit_size; ++i) {
+                FF T0 = this->sorted_polynomials[3][i];
+                T0 *= eta;
+                T0 += this->sorted_polynomials[2][i];
+                T0 *= eta;
+                T0 += this->sorted_polynomials[1][i];
+                T0 *= eta;
+                T0 += this->sorted_polynomials[0][i];
+                sorted_list_accumulator[i] = T0;
+            }
+            this->sorted_accum = sorted_list_accumulator.share();
+        }
+
+        void compute_sorted_accumulator_polynomials(FF eta)
+        {
+            // Compute sorted witness-table accumulator
+            this->compute_sorted_list_accumulator(eta);
+
+            // Finalize fourth wire polynomial by adding lookup memory records
+            add_plookup_memory_records_to_wire_4(eta);
+        }
+
+        /**
+         * @brief Add plookup memory records to the fourth wire polynomial
+         *
+         * @details This operation must be performed after the first three wires have been committed to, hence the
+         * dependence on the `eta` challenge.
+         *
+         * @tparam Flavor
+         * @param eta challenge produced after commitment to first three wire polynomials
+         */
+        void add_plookup_memory_records_to_wire_4(FF eta)
+        {
+            // The plookup memory record values are computed at the indicated indices as
+            // w4 = w3 * eta^3 + w2 * eta^2 + w1 * eta + read_write_flag;
+            // (See plookup_auxiliary_widget.hpp for details)
+            auto wires = this->get_wires();
+
+            // Compute read record values
+            for (const auto& gate_idx : this->memory_read_records) {
+                wires[3][gate_idx] += wires[2][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += wires[1][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += wires[0][gate_idx];
+                wires[3][gate_idx] *= eta;
+            }
+
+            // Compute write record values
+            for (const auto& gate_idx : this->memory_write_records) {
+                wires[3][gate_idx] += wires[2][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += wires[1][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += wires[0][gate_idx];
+                wires[3][gate_idx] *= eta;
+                wires[3][gate_idx] += 1;
+            }
+        }
+
+        void compute_grand_product_polynomials(RelationParameters<FF>& relation_parameters)
+        {
+            auto public_input_delta = compute_public_input_delta<UltraFlavor>(this->public_inputs,
+                                                                              relation_parameters.beta,
+                                                                              relation_parameters.gamma,
+                                                                              this->circuit_size,
+                                                                              this->pub_inputs_offset);
+            relation_parameters.public_input_delta = public_input_delta;
+            auto lookup_grand_product_delta = compute_lookup_grand_product_delta(
+                relation_parameters.beta, relation_parameters.gamma, this->circuit_size);
+            relation_parameters.lookup_grand_product_delta = lookup_grand_product_delta;
+
+            // Compute permutation and lookup grand product polynomials
+            auto proving_key_ptr = std::make_shared<ProvingKey>(*this);
+            auto prover_polynomials = ProverPolynomials(proving_key_ptr);
+            compute_grand_products<UltraFlavor>(proving_key_ptr, prover_polynomials, relation_parameters);
+            this->z_perm = prover_polynomials.z_perm;
+            this->z_lookup = prover_polynomials.z_lookup;
+        }
     };
 
     /**
@@ -307,6 +408,17 @@ class UltraFlavor {
      */
     class ProverPolynomials : public AllEntities<Polynomial> {
       public:
+        ProverPolynomials(std::shared_ptr<ProvingKey>& proving_key)
+        {
+            for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key->get_all())) {
+                ASSERT(flavor_get_label(*this, prover_poly) == flavor_get_label(*proving_key, key_poly));
+                prover_poly = key_poly.share();
+            }
+            for (auto [prover_poly, key_poly] : zip_view(this->get_shifted(), proving_key->get_to_be_shifted())) {
+                ASSERT(flavor_get_label(*this, prover_poly) == (flavor_get_label(*proving_key, key_poly) + "_shift"));
+                prover_poly = key_poly.shifted();
+            }
+        }
         // Define all operations as default, except move construction/assignment
         ProverPolynomials() = default;
         ProverPolynomials& operator=(const ProverPolynomials&) = delete;

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

@@ -117,16 +117,17 @@ template <typename Flavor> class ProtoGalaxyTests : public testing::Test {
         construct_circuit(builder);
 
         auto instance = std::make_shared<ProverInstance>(builder);
-        instance->initialize_prover_polynomials();
 
-        auto eta = FF::random_element();
-        auto beta = FF::random_element();
-        auto gamma = FF::random_element();
-        instance->compute_sorted_accumulator_polynomials(eta);
+        instance->relation_parameters.eta = 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);
         if constexpr (IsGoblinFlavor<Flavor>) {
-            instance->compute_logderivative_inverse(beta, gamma);
+            instance->proving_key->compute_logderivative_inverse(instance->relation_parameters);
         }
-        instance->compute_grand_product_polynomials(beta, gamma);
+        instance->proving_key->compute_grand_product_polynomials(instance->relation_parameters);
+        instance->prover_polynomials = ProverPolynomials(instance->proving_key);
 
         for (auto& alpha : instance->alphas) {
             alpha = FF::random_element();

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

@@ -6,22 +6,11 @@ template <class ProverInstances>
 void ProtoGalaxyProver_<ProverInstances>::finalise_and_send_instance(std::shared_ptr<Instance> instance,
                                                                      const std::string& domain_separator)
 {
-    OinkProver<Flavor> oink_prover(instance, commitment_key, transcript, domain_separator + '_');
+    OinkProver<Flavor> oink_prover(instance->proving_key, commitment_key, transcript, domain_separator + '_');
 
-    // Add circuit size public input size and public inputs to transcript
-    oink_prover.execute_preamble_round();
-
-    // Compute first three wire commitments
-    oink_prover.execute_wire_commitments_round();
-
-    // Compute sorted list accumulator and commitment
-    oink_prover.execute_sorted_list_accumulator_round();
-
-    // Fiat-Shamir: beta & gamma
-    oink_prover.execute_log_derivative_inverse_round();
-
-    // Compute grand product(s) and commitments.
-    oink_prover.execute_grand_product_computation_round();
+    auto [relation_params] = oink_prover.prove();
+    instance->relation_parameters = std::move(relation_params);
+    instance->prover_polynomials = ProverPolynomials(instance->proving_key);
 
     // Generate relation separators alphas for sumcheck
     for (size_t idx = 0; idx < NUM_SUBRELATIONS - 1; idx++) {