chore: return of the instance (#17043)

Historically we have named the tuple `(\omega, \phi)` in PG paper
ProverInstance and VerifierInstance (what gets folded prover and
verifier side). A `ProverInstance` contains all the information to
generate a proof of its satisfiability, that is commitments to wires
polynomials, relation parameters and fully constructed
`ProverPolynomials` - including those requiring challenges in their
construction. We temporarily moved from terminology `ProverInstance` and
`VerifierInstance` to `DeciderProvingKey` and `DeciderVerificationKey`.
But that has caused many times confusion with the `VerificationKey`
(i.e. commitments to precomputed polys) and questions as to why does the
vk contain witness commitments. Hence, to hopefully avoid these
confusions from now on - return of the instance is here!

Author: maramihali

barretenberg/cpp/scripts/test_civc_standalone_vks_havent_changed.sh

@@ -8,7 +8,7 @@
 #include "barretenberg/dsl/acir_format/proof_surgeon.hpp"
 #include "barretenberg/flavor/ultra_flavor.hpp"
 #include "barretenberg/flavor/ultra_rollup_flavor.hpp"
-#include "barretenberg/ultra_honk/decider_proving_key.hpp"
+#include "barretenberg/ultra_honk/prover_instance.hpp"
 #include <chrono>
 #include <cstddef>
 #include <cstdlib>

barretenberg/cpp/src/barretenberg/api/api_ultra_honk.test.cpp

@@ -55,12 +55,13 @@ void prove_tube(const std::string& output_path, const std::string& vk_path)
 
     using Prover = UltraProver_<UltraRollupFlavor>;
     using Verifier = UltraVerifier_<UltraRollupFlavor>;
-    auto proving_key = std::make_shared<DeciderProvingKey_<UltraRollupFlavor>>(builder);
+    auto prover_instance = std::make_shared<ProverInstance_<UltraRollupFlavor>>(builder);
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/1201): Precompute tube vk and pass it in.
     info("WARNING: computing tube vk in prove_tube, but a precomputed vk should be passed in.");
-    auto tube_verification_key = std::make_shared<UltraRollupFlavor::VerificationKey>(proving_key->get_precomputed());
+    auto tube_verification_key =
+        std::make_shared<UltraRollupFlavor::VerificationKey>(prover_instance->get_precomputed());
 
-    Prover tube_prover{ proving_key, tube_verification_key };
+    Prover tube_prover{ prover_instance, tube_verification_key };
     auto tube_proof = tube_prover.construct_proof();
     std::string tubePublicInputsPath = output_path + "/public_inputs";
     std::string tubeProofPath = output_path + "/proof";

barretenberg/cpp/src/barretenberg/api/prove_tube.cpp

@@ -111,13 +111,13 @@ ClientIvcVerify::Response ClientIvcVerify::execute(const BBApiRequest& /*request
     return { .valid = verified };
 }
 
-static std::shared_ptr<ClientIVC::DeciderProvingKey> get_acir_program_decider_proving_key(
-    const BBApiRequest& request, acir_format::AcirProgram& program)
+static std::shared_ptr<ClientIVC::ProverInstance> get_acir_program_prover_instance(const BBApiRequest& request,
+                                                                                   acir_format::AcirProgram& program)
 {
     ClientIVC::ClientCircuit builder = acir_format::create_circuit<ClientIVC::ClientCircuit>(program);
 
     // Construct the verification key via the prover-constructed proving key with the proper trace settings
-    return std::make_shared<ClientIVC::DeciderProvingKey>(builder, request.trace_settings);
+    return std::make_shared<ClientIVC::ProverInstance>(builder, request.trace_settings);
 }
 
 ClientIvcComputeStandaloneVk::Response ClientIvcComputeStandaloneVk::execute(const BBApiRequest& request) &&
@@ -128,8 +128,8 @@ ClientIvcComputeStandaloneVk::Response ClientIvcComputeStandaloneVk::execute(con
     auto constraint_system = acir_format::circuit_buf_to_acir_format(std::move(circuit.bytecode));
 
     acir_format::AcirProgram program{ constraint_system, /*witness=*/{} };
-    std::shared_ptr<ClientIVC::DeciderProvingKey> proving_key = get_acir_program_decider_proving_key(request, program);
-    auto verification_key = std::make_shared<ClientIVC::MegaVerificationKey>(proving_key->get_precomputed());
+    std::shared_ptr<ClientIVC::ProverInstance> prover_instance = get_acir_program_prover_instance(request, program);
+    auto verification_key = std::make_shared<ClientIVC::MegaVerificationKey>(prover_instance->get_precomputed());
 
     return { .bytes = to_buffer(*verification_key), .fields = verification_key->to_field_elements() };
 }
@@ -163,8 +163,8 @@ ClientIvcCheckPrecomputedVk::Response ClientIvcCheckPrecomputedVk::execute(const
     acir_format::AcirProgram program{ acir_format::circuit_buf_to_acir_format(std::move(circuit.bytecode)),
                                       /*witness=*/{} };
 
-    std::shared_ptr<ClientIVC::DeciderProvingKey> proving_key = get_acir_program_decider_proving_key(request, program);
-    auto computed_vk = std::make_shared<ClientIVC::MegaVerificationKey>(proving_key->get_precomputed());
+    std::shared_ptr<ClientIVC::ProverInstance> prover_instance = get_acir_program_prover_instance(request, program);
+    auto computed_vk = std::make_shared<ClientIVC::MegaVerificationKey>(prover_instance->get_precomputed());
 
     if (circuit.verification_key.empty()) {
         info("FAIL: Expected precomputed vk for function ", circuit.name);

barretenberg/cpp/src/barretenberg/bbapi/bbapi_client_ivc.cpp

@@ -19,7 +19,7 @@
 #include "barretenberg/flavor/ultra_zk_flavor.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
 #include "barretenberg/special_public_inputs/special_public_inputs.hpp"
-#include "barretenberg/ultra_honk/decider_proving_key.hpp"
+#include "barretenberg/ultra_honk/prover_instance.hpp"
 #include "barretenberg/ultra_honk/ultra_prover.hpp"
 #include "barretenberg/ultra_honk/ultra_verifier.hpp"
 #include <type_traits>
@@ -63,17 +63,17 @@ Circuit _compute_circuit(std::vector<uint8_t>&& bytecode, std::vector<uint8_t>&&
 }
 
 template <typename Flavor>
-std::shared_ptr<DeciderProvingKey_<Flavor>> _compute_proving_key(std::vector<uint8_t>&& bytecode,
-                                                                 std::vector<uint8_t>&& witness)
+std::shared_ptr<ProverInstance_<Flavor>> _compute_prover_instance(std::vector<uint8_t>&& bytecode,
+                                                                  std::vector<uint8_t>&& witness)
 {
     // Measure function time and debug print
     auto initial_time = std::chrono::high_resolution_clock::now();
     typename Flavor::CircuitBuilder builder = _compute_circuit<Flavor>(std::move(bytecode), std::move(witness));
-    auto decider_proving_key = std::make_shared<DeciderProvingKey_<Flavor>>(builder);
+    auto prover_instance = std::make_shared<ProverInstance_<Flavor>>(builder);
     auto final_time = std::chrono::high_resolution_clock::now();
     auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(final_time - initial_time);
     info("CircuitProve: Proving key computed in ", duration.count(), " ms");
-    return decider_proving_key;
+    return prover_instance;
 }
 template <typename Flavor>
 CircuitProve::Response _prove(std::vector<uint8_t>&& bytecode,
@@ -82,22 +82,22 @@ CircuitProve::Response _prove(std::vector<uint8_t>&& bytecode,
 {
     using Proof = typename Flavor::Transcript::Proof;
 
-    auto proving_key = _compute_proving_key<Flavor>(std::move(bytecode), std::move(witness));
+    auto prover_instance = _compute_prover_instance<Flavor>(std::move(bytecode), std::move(witness));
     std::shared_ptr<typename Flavor::VerificationKey> vk;
     if (vk_bytes.empty()) {
         info("WARNING: computing verification key while proving. Pass in a precomputed vk for better performance.");
-        vk = std::make_shared<typename Flavor::VerificationKey>(proving_key->get_precomputed());
+        vk = std::make_shared<typename Flavor::VerificationKey>(prover_instance->get_precomputed());
     } else {
         vk =
             std::make_shared<typename Flavor::VerificationKey>(from_buffer<typename Flavor::VerificationKey>(vk_bytes));
     }
 
-    UltraProver_<Flavor> prover{ proving_key, vk };
+    UltraProver_<Flavor> prover{ prover_instance, vk };
 
     Proof concat_pi_and_proof = prover.construct_proof();
     // Compute number of inner public inputs. Perform loose checks that the public inputs contain enough data.
     auto num_inner_public_inputs = [&]() {
-        size_t num_public_inputs = prover.proving_key->num_public_inputs();
+        size_t num_public_inputs = prover.prover_instance->num_public_inputs();
         if constexpr (HasIPAAccumulator<Flavor>) {
             BB_ASSERT_GTE(num_public_inputs,
                           RollupIO::PUBLIC_INPUTS_SIZE,
@@ -242,8 +242,8 @@ CircuitComputeVk::Response CircuitComputeVk::execute(BB_UNUSED const BBApiReques
 
     // Helper lambda to compute VK, fields, and hash for a given flavor
     auto compute_vk_and_fields = [&]<typename Flavor>() {
-        auto proving_key = _compute_proving_key<Flavor>(std::move(circuit.bytecode), {});
-        auto vk = std::make_shared<typename Flavor::VerificationKey>(proving_key->get_precomputed());
+        auto prover_instance = _compute_prover_instance<Flavor>(std::move(circuit.bytecode), {});
+        auto vk = std::make_shared<typename Flavor::VerificationKey>(prover_instance->get_precomputed());
         vk_bytes = to_buffer(*vk);
         if constexpr (IsAnyOf<Flavor, UltraKeccakFlavor, UltraKeccakZKFlavor>) {
             vk_fields = vk->to_field_elements();

barretenberg/cpp/src/barretenberg/bbapi/bbapi_ultra_honk.cpp

@@ -5,8 +5,8 @@
 #include "barretenberg/protogalaxy/protogalaxy_prover_internal.hpp"
 #include "barretenberg/stdlib_circuit_builders/mock_circuits.hpp"
 #include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
-#include "barretenberg/ultra_honk/decider_keys.hpp"
-#include "barretenberg/ultra_honk/decider_proving_key.hpp"
+#include "barretenberg/ultra_honk/instances.hpp"
+#include "barretenberg/ultra_honk/prover_instance.hpp"
 
 using namespace benchmark;
 
@@ -27,7 +27,7 @@ void vector_of_evaluations(State& state) noexcept
 
 void compute_row_evaluations(State& state) noexcept
 {
-    using PGInternal = ProtogalaxyProverInternal<DeciderProvingKeys_<Flavor, 2>>;
+    using PGInternal = ProtogalaxyProverInternal<ProverInstances_<Flavor, 2>>;
     using Polys = Flavor::ProverPolynomials;
     using Alphas = Flavor::SubrelationSeparators;
     using Params = RelationParameters<FF>;
@@ -44,39 +44,38 @@ void compute_row_evaluations(State& state) noexcept
     }
 }
 
-// Fold one proving key into an accumulator.
-void fold_k(State& state) noexcept
+// Fold one instance into an accumulator.
+void fold(State& state) noexcept
 {
-    static constexpr size_t k{ 1 };
 
-    using DeciderProvingKey = DeciderProvingKey_<Flavor>;
-    using DeciderVerificationKey = DeciderVerificationKey_<Flavor>;
-    using ProtogalaxyProver = ProtogalaxyProver_<Flavor, k + 1>;
+    using ProverInstance = ProverInstance_<Flavor>;
+    using VerifierInstance = VerifierInstance_<Flavor>;
+    using ProtogalaxyProver = ProtogalaxyProver_<Flavor, 2>;
     using Builder = typename Flavor::CircuitBuilder;
 
     bb::srs::init_file_crs_factory(bb::srs::bb_crs_path());
 
     auto log2_num_gates = static_cast<size_t>(state.range(0));
 
-    const auto construct_key = [&]() {
+    const auto construct_inst = [&]() {
         Builder builder;
         MockCircuits::construct_arithmetic_circuit(builder, log2_num_gates);
-        return std::make_shared<DeciderProvingKey>(builder);
+        return std::make_shared<ProverInstance>(builder);
     };
-    std::vector<std::shared_ptr<DeciderProvingKey>> decider_pks;
-    std::vector<std::shared_ptr<DeciderVerificationKey>> decider_vks;
+    std::vector<std::shared_ptr<ProverInstance>> prover_insts;
+    std::vector<std::shared_ptr<VerifierInstance>> verifier_insts;
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/938): Parallelize this loop
-    for (size_t i = 0; i < k + 1; ++i) {
-        std::shared_ptr<DeciderProvingKey> decider_pk = construct_key();
-        auto honk_vk = std::make_shared<Flavor::VerificationKey>(decider_pk->get_precomputed());
-        std::shared_ptr<DeciderVerificationKey> decider_vk = std::make_shared<DeciderVerificationKey>(honk_vk);
-        decider_pks.emplace_back(decider_pk);
-        decider_vks.emplace_back(decider_vk);
+    for (size_t i = 0; i < 2; ++i) {
+        std::shared_ptr<ProverInstance> prover_inst = construct_inst();
+        auto honk_vk = std::make_shared<Flavor::VerificationKey>(prover_inst->get_precomputed());
+        std::shared_ptr<VerifierInstance> verifier_inst = std::make_shared<VerifierInstance>(honk_vk);
+        prover_insts.emplace_back(prover_inst);
+        verifier_insts.emplace_back(verifier_inst);
     }
     std::shared_ptr<typename ProtogalaxyProver::Transcript> transcript =
         std::make_shared<typename ProtogalaxyProver::Transcript>();
 
-    ProtogalaxyProver folding_prover(decider_pks, decider_vks, transcript);
+    ProtogalaxyProver folding_prover(prover_insts, verifier_insts, transcript);
 
     for (auto _ : state) {
         GOOGLE_BB_BENCH_REPORTER(state);
@@ -87,7 +86,7 @@ void fold_k(State& state) noexcept
 BENCHMARK(vector_of_evaluations)->DenseRange(15, 21)->Unit(kMillisecond)->Iterations(1);
 BENCHMARK(compute_row_evaluations)->DenseRange(15, 21)->Unit(kMillisecond);
 // We stick to just k=1 for compile-time reasons.
-BENCHMARK(fold_k)->/* vary the circuit size */ DenseRange(14, 20)->Unit(kMillisecond);
+BENCHMARK(fold)->/* vary the circuit size */ DenseRange(14, 20)->Unit(kMillisecond);
 
 } // namespace bb