feat: protogalaxy interfaces

barretenberg/cpp/src/barretenberg/benchmark/honk_bench/benchmark_utilities.hpp

@@ -1,5 +1,8 @@
 #include <benchmark/benchmark.h>
 
+#include "barretenberg/honk/composer/standard_composer.hpp"
+#include "barretenberg/honk/composer/ultra_composer.hpp"
+#include "barretenberg/proof_system/types/circuit_type.hpp"
 #include "barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp"
 #include "barretenberg/stdlib/hash/keccak/keccak.hpp"
 #include "barretenberg/stdlib/hash/sha256/sha256.hpp"
@@ -192,11 +195,20 @@ void construct_proof_with_specified_num_gates(State& state,
         test_circuit_function(builder, num_gates);
 
         auto composer = Composer();
-        auto ext_prover = composer.create_prover(builder);
-        state.ResumeTiming();
-
-        // Construct proof
-        auto proof = ext_prover.construct_proof();
+        if constexpr (proof_system::IsAnyOf<Composer, proof_system::honk::StandardComposer>) {
+            auto instance = composer.create_instance(builder);
+            auto ext_prover = composer.create_prover(instance);
+            state.ResumeTiming();
+
+            // Construct proof
+            auto proof = ext_prover.construct_proof();
+        } else {
+            auto ext_prover = composer.create_prover(builder);
+            state.ResumeTiming();
+
+            // Construct proof
+            auto proof = ext_prover.construct_proof();
+        }
     }
 }
 
@@ -224,11 +236,21 @@ void construct_proof_with_specified_num_iterations(State& state,
         test_circuit_function(builder, num_iterations);
 
         auto composer = Composer();
-        auto ext_prover = composer.create_prover(builder);
-        state.ResumeTiming();
+        if constexpr (proof_system::IsAnyOf<Composer, proof_system::honk::UltraComposer>) {
+            auto instance = composer.create_instance(builder);
+            auto ext_prover = composer.create_prover(instance);
+            state.ResumeTiming();
+
+            // Construct proof
+            auto proof = ext_prover.construct_proof();
+
+        } else {
+            auto ext_prover = composer.create_prover(builder);
+            state.ResumeTiming();
 
-        // Construct proof
-        auto proof = ext_prover.construct_proof();
+            // Construct proof
+            auto proof = ext_prover.construct_proof();
+        }
     }
 }
 

barretenberg/cpp/src/barretenberg/honk/composer/goblin_ultra_composer.test.cpp

@@ -27,7 +27,9 @@ class GoblinUltraHonkComposerTests : public ::testing::Test {
  */
 TEST_F(GoblinUltraHonkComposerTests, SimpleCircuit)
 {
-    auto builder = UltraCircuitBuilder();
+    using fr = barretenberg::fr;
+    using g1 = barretenberg::g1;
+    auto builder = proof_system::UltraCircuitBuilder();
 
     // Define an arbitrary number of operations/gates
     size_t num_ecc_ops = 3;
@@ -55,8 +57,9 @@ TEST_F(GoblinUltraHonkComposerTests, SimpleCircuit)
     }
 
     auto composer = GoblinUltraComposer();
-    auto prover = composer.create_prover(builder);
-    auto verifier = composer.create_verifier(builder);
+    auto instance = composer.create_instance(builder);
+    auto prover = composer.create_prover(instance);
+    auto verifier = composer.create_verifier(instance);
     auto proof = prover.construct_proof();
     bool verified = verifier.verify_proof(proof);
     EXPECT_EQ(verified, true);

barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.cpp

@@ -9,122 +9,30 @@
 
 namespace proof_system::honk {
 
-/**
- * Compute witness polynomials (w_1, w_2, w_3, w_4).
- *
- * @details Fills 3 or 4 witness polynomials w_1, w_2, w_3, w_4 with the values of in-circuit variables. The beginning
- * of w_1, w_2 polynomials is filled with public_input values.
- * @return Witness with computed witness polynomials.
- *
- * @tparam Program settings needed to establish if w_4 is being used.
- * */
 template <StandardFlavor Flavor>
-void StandardComposer_<Flavor>::compute_witness(const CircuitBuilder& circuit_constructor, const size_t /*unused*/)
+std::shared_ptr<ProverInstance_<Flavor>> StandardComposer_<Flavor>::create_instance(CircuitBuilder& circuit)
 {
-    if (computed_witness) {
-        return;
-    }
-    auto wire_polynomials = construct_wire_polynomials_base<Flavor>(circuit_constructor, dyadic_circuit_size);
-
-    proving_key->w_l = wire_polynomials[0];
-    proving_key->w_r = wire_polynomials[1];
-    proving_key->w_o = wire_polynomials[2];
-
-    computed_witness = true;
-}
-
-/**
- * Compute proving key.
- * Compute the polynomials q_l, q_r, etc. and sigma polynomial.
- *
- * @return Proving key with saved computed polynomials.
- * */
-
-template <StandardFlavor Flavor>
-std::shared_ptr<typename Flavor::ProvingKey> StandardComposer_<Flavor>::compute_proving_key(
-    const CircuitBuilder& circuit_constructor)
-{
-    if (proving_key) {
-        return proving_key;
-    }
-
-    // Construct a proving key
-    proving_key = std::make_shared<ProvingKey>(dyadic_circuit_size, num_public_inputs);
-
-    // Compute lagrange selectors
-    construct_selector_polynomials<Flavor>(circuit_constructor, proving_key.get());
-
-    // Compute sigma polynomials (we should update that late)
-    compute_standard_honk_sigma_permutations<Flavor>(circuit_constructor, proving_key.get());
-    compute_standard_honk_id_polynomials<Flavor>(proving_key.get());
-
-    compute_first_and_last_lagrange_polynomials<Flavor>(proving_key.get());
-
-    return proving_key;
+    auto instance = std::make_shared<Instance>(circuit);
+    instance->commitment_key = compute_commitment_key(instance->proving_key->circuit_size);
+    return instance;
 }
 
-/**
- * Compute verification key consisting of selector precommitments.
- *
- * @return Pointer to created circuit verification key.
- * */
 template <StandardFlavor Flavor>
-std::shared_ptr<typename Flavor::VerificationKey> StandardComposer_<Flavor>::compute_verification_key(
-    const CircuitBuilder& /*unused*/)
+StandardVerifier_<Flavor> StandardComposer_<Flavor>::create_verifier(std::shared_ptr<Instance> instance)
 {
-    if (verification_key) {
-        return verification_key;
-    }
-
-    verification_key =
-        std::make_shared<typename Flavor::VerificationKey>(proving_key->circuit_size, proving_key->num_public_inputs);
-
-    // Compute and store commitments to all precomputed polynomials
-    verification_key->q_m = commitment_key->commit(proving_key->q_m);
-    verification_key->q_l = commitment_key->commit(proving_key->q_l);
-    verification_key->q_r = commitment_key->commit(proving_key->q_r);
-    verification_key->q_o = commitment_key->commit(proving_key->q_o);
-    verification_key->q_c = commitment_key->commit(proving_key->q_c);
-    verification_key->sigma_1 = commitment_key->commit(proving_key->sigma_1);
-    verification_key->sigma_2 = commitment_key->commit(proving_key->sigma_2);
-    verification_key->sigma_3 = commitment_key->commit(proving_key->sigma_3);
-    verification_key->id_1 = commitment_key->commit(proving_key->id_1);
-    verification_key->id_2 = commitment_key->commit(proving_key->id_2);
-    verification_key->id_3 = commitment_key->commit(proving_key->id_3);
-    verification_key->lagrange_first = commitment_key->commit(proving_key->lagrange_first);
-    verification_key->lagrange_last = commitment_key->commit(proving_key->lagrange_last);
-
-    return verification_key;
-}
-
-template <StandardFlavor Flavor>
-StandardVerifier_<Flavor> StandardComposer_<Flavor>::create_verifier(const CircuitBuilder& circuit_constructor)
-{
-    compute_verification_key(circuit_constructor);
+    auto verification_key = instance->compute_verification_key();
     StandardVerifier_<Flavor> output_state(verification_key);
-
     auto pcs_verification_key =
         std::make_unique<typename Flavor::VerifierCommitmentKey>(verification_key->circuit_size, crs_factory_);
-
     output_state.pcs_verification_key = std::move(pcs_verification_key);
 
     return output_state;
 }
 
 template <StandardFlavor Flavor>
-StandardProver_<Flavor> StandardComposer_<Flavor>::create_prover(const CircuitBuilder& circuit_constructor)
+StandardProver_<Flavor> StandardComposer_<Flavor>::create_prover(std::shared_ptr<Instance> instance)
 {
-    // Compute some key cicuit size paramaters
-    num_public_inputs = circuit_constructor.public_inputs.size();
-    total_num_gates = circuit_constructor.num_gates + num_public_inputs;
-    dyadic_circuit_size = circuit_constructor.get_circuit_subgroup_size(total_num_gates);
-
-    compute_proving_key(circuit_constructor);
-    compute_witness(circuit_constructor);
-
-    compute_commitment_key(proving_key->circuit_size);
-
-    StandardProver_<Flavor> output_state(proving_key, commitment_key);
+    StandardProver_<Flavor> output_state(instance);
 
     return output_state;
 }

barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "barretenberg/honk/instance/prover_instance.hpp"
 #include "barretenberg/honk/proof_system/prover.hpp"
 #include "barretenberg/honk/proof_system/verifier.hpp"
 #include "barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp"
@@ -18,6 +19,7 @@ template <StandardFlavor Flavor> class StandardComposer_ {
     using ProvingKey = typename Flavor::ProvingKey;
     using VerificationKey = typename Flavor::VerificationKey;
     using CommitmentKey = typename Flavor::CommitmentKey;
+    using Instance = ProverInstance_<Flavor>;
 
     static constexpr std::string_view NAME_STRING = "StandardHonk";
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;
@@ -29,14 +31,11 @@ template <StandardFlavor Flavor> class StandardComposer_ {
 
     // The commitment key is passed to the prover but also used herein to compute the verfication key commitments
     std::shared_ptr<CommitmentKey> commitment_key;
-
-    size_t total_num_gates;     // total num gates prior to computing dyadic size
-    size_t dyadic_circuit_size; // final dyadic circuit size
-    size_t num_public_inputs;
+    ;
 
     bool computed_witness = false;
     // TODO(Luke): use make_shared
-    // TODO(#637): design the crs factory better
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/637): design the crs factory better
     StandardComposer_()
     {
         if constexpr (IsGrumpkinFlavor<Flavor>) {
@@ -64,18 +63,15 @@ template <StandardFlavor Flavor> class StandardComposer_ {
     StandardComposer_& operator=(const StandardComposer_& other) = delete;
     ~StandardComposer_() = default;
 
-    std::shared_ptr<ProvingKey> compute_proving_key(const CircuitBuilder& circuit_constructor);
-    std::shared_ptr<VerificationKey> compute_verification_key(const CircuitBuilder& circuit_constructor);
-
-    StandardVerifier_<Flavor> create_verifier(const CircuitBuilder& circuit_constructor);
-
-    StandardProver_<Flavor> create_prover(const CircuitBuilder& circuit_constructor);
+    std::shared_ptr<Instance> create_instance(CircuitBuilder& circuit);
 
-    void compute_witness(const CircuitBuilder& circuit_constructor, const size_t minimum_circuit_size = 0);
+    StandardProver_<Flavor> create_prover(std::shared_ptr<Instance>);
+    StandardVerifier_<Flavor> create_verifier(std::shared_ptr<Instance>);
 
-    void compute_commitment_key(size_t circuit_size)
+    std::shared_ptr<CommitmentKey> compute_commitment_key(size_t circuit_size)
     {
         commitment_key = std::make_shared<CommitmentKey>(circuit_size, crs_factory_);
+        return commitment_key;
     };
 };