chore: simplify is_accum (#16291)

Simplify some PG state, including the `is_accumulator` flag which was
serving two purposes for the prover and was not really needed at all for
the verifier. Both prover and verifier now have `is_complete` which
indicates whether the instance has been "oinked" i.e. completed

---------

Co-authored-by: AztecBot <tech@aztecprotocol.com>

Author: ledwards2225

barretenberg/cpp/src/barretenberg/client_ivc/client_ivc.cpp

@@ -139,7 +139,6 @@ std::pair<ClientIVC::PairingPoints, ClientIVC::TableCommitments> ClientIVC::
         // Perform oink recursive verification to complete the initial verifier accumulator
         OinkRecursiveVerifier verifier{ &circuit, verifier_accum, accumulation_recursive_transcript };
         verifier.verify_proof(verifier_inputs.proof);
-        verifier_accum->is_accumulator = true; // indicate to PG that it should not run oink
 
         // Extract native verifier accumulator from the stdlib accum for use on the next round
         recursive_verifier_native_accum = std::make_shared<DeciderVerificationKey>(verifier_accum->get_value());
@@ -339,9 +338,6 @@ void ClientIVC::accumulate(ClientCircuit& circuit, const std::shared_ptr<MegaVer
         oink_prover.prove();
         HonkProof oink_proof = oink_prover.export_proof();
         vinfo("oink proof constructed");
-        proving_key->is_accumulator = true; // indicate to PG that it should not run oink on this key
-        // Initialize the gate challenges to zero for use in first round of folding
-        proving_key->gate_challenges = std::vector<FF>(CONST_PG_LOG_N, 0);
 
         fold_output.accumulator = proving_key; // initialize the prover accum with the completed key
 
@@ -350,7 +346,6 @@ void ClientIVC::accumulate(ClientCircuit& circuit, const std::shared_ptr<MegaVer
         OinkVerifier<Flavor> oink_verifier{ decider_vk, oink_verifier_transcript };
         oink_verifier.verify();
         native_verifier_accum = decider_vk;
-        native_verifier_accum->is_accumulator = true;
         native_verifier_accum->gate_challenges = std::vector<FF>(CONST_PG_LOG_N, 0);
 
         queue_entry.type = QUEUE_TYPE::OINK;

barretenberg/cpp/src/barretenberg/dsl/acir_format/mock_verifier_inputs.cpp

@@ -224,7 +224,7 @@ template <typename Flavor> std::shared_ptr<DeciderVerificationKey_<Flavor>> crea
         create_mock_honk_vk<Flavor, stdlib::recursion::honk::DefaultIO<typename Flavor::CircuitBuilder>>(
             0, 0); // metadata does not need to be accurate
     decider_verification_key->vk = vk;
-    decider_verification_key->is_accumulator = true;
+    decider_verification_key->is_complete = true;
     decider_verification_key->gate_challenges = std::vector<FF>(static_cast<size_t>(CONST_PG_LOG_N), 0);
 
     for (auto& commitment : decider_verification_key->witness_commitments.get_all()) {

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

@@ -33,10 +33,8 @@ void ProtogalaxyProver_<Flavor, NUM_KEYS>::run_oink_prover_on_each_incomplete_ke
     auto& key = keys_to_fold[0];
     auto domain_separator = std::to_string(idx);
     auto& verifier_accum = vks_to_fold[0];
-    if (!key->is_accumulator) {
+    if (!key->is_complete) {
         run_oink_prover_on_one_incomplete_key(key, verifier_accum, domain_separator);
-        key->target_sum = 0;
-        key->gate_challenges = std::vector<FF>(CONST_PG_LOG_N, 0);
     } else {
         // Fiat-Shamir the verifier accumulator
         FF accum_hash = verifier_accum->add_hash_to_transcript("", *transcript);

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

@@ -19,10 +19,9 @@ void ProtogalaxyVerifier_<DeciderVerificationKeys>::run_oink_verifier_on_each_in
     transcript->load_proof(proof);
     auto key = keys_to_fold[0];
     auto domain_separator = std::to_string(0);
-    if (!key->is_accumulator) {
+    if (!key->is_complete) {
         OinkVerifier<Flavor> oink_verifier{ key, transcript, domain_separator + '_' };
         oink_verifier.verify();
-        key->target_sum = 0;
         key->gate_challenges = std::vector<FF>(CONST_PG_LOG_N, 0);
     } else {
         // Fiat-Shamir the verifier accumulator
@@ -73,8 +72,11 @@ std::shared_ptr<typename DeciderVerificationKeys::DeciderVK> ProtogalaxyVerifier
 {
     static constexpr size_t BATCHED_EXTENDED_LENGTH = DeciderVerificationKeys::BATCHED_EXTENDED_LENGTH;
     static constexpr size_t NUM_KEYS = DeciderVerificationKeys::NUM;
+    // The degree of the combiner quotient (K in the paper) is dk - k - 1 = k(d - 1) - 1.
+    // Hence we need  k(d - 1) evaluations to represent it.
+    static constexpr size_t COMBINER_LENGTH = BATCHED_EXTENDED_LENGTH - NUM_KEYS;
 
-    const std::shared_ptr<const DeciderVK>& accumulator = keys_to_fold[0];
+    const std::shared_ptr<DeciderVK>& accumulator = keys_to_fold[0];
 
     run_oink_verifier_on_each_incomplete_key(proof);
 
@@ -92,9 +94,7 @@ std::shared_ptr<typename DeciderVerificationKeys::DeciderVK> ProtogalaxyVerifier
     const Polynomial<FF> perturbator(perturbator_coeffs);
     const FF perturbator_evaluation = perturbator.evaluate(perturbator_challenge);
 
-    std::array<FF, BATCHED_EXTENDED_LENGTH - NUM_KEYS>
-        combiner_quotient_evals; // The degree of the combiner quotient (K in the paper) is dk - k - 1 = k(d - 1) - 1.
-                                 // Hence we need  k(d - 1) evaluations to represent it.
+    std::array<FF, COMBINER_LENGTH> combiner_quotient_evals;
     for (size_t idx = DeciderVerificationKeys::NUM; auto& val : combiner_quotient_evals) {
         val = transcript->template receive_from_prover<FF>("combiner_quotient_" + std::to_string(idx++));
     }
@@ -104,42 +104,38 @@ std::shared_ptr<typename DeciderVerificationKeys::DeciderVK> ProtogalaxyVerifier
     const Univariate<FF, BATCHED_EXTENDED_LENGTH, NUM_KEYS> combiner_quotient(combiner_quotient_evals);
     const FF combiner_quotient_evaluation = combiner_quotient.evaluate(combiner_challenge);
 
-    auto next_accumulator = std::make_shared<DeciderVK>();
-    next_accumulator->vk = std::make_shared<VerificationKey>(*accumulator->vk);
-    next_accumulator->is_accumulator = true;
-
     // Set the accumulator circuit size data based on the max of the keys being accumulated
     const size_t accumulator_log_circuit_size = keys_to_fold.get_max_log_circuit_size();
-    next_accumulator->vk->log_circuit_size = accumulator_log_circuit_size;
+    accumulator->vk->log_circuit_size = accumulator_log_circuit_size;
 
     // Compute next folding parameters
     const auto [vanishing_polynomial_at_challenge, lagranges] =
         compute_vanishing_polynomial_and_lagrange_evaluations<FF, NUM_KEYS>(combiner_challenge);
-    next_accumulator->target_sum =
+    accumulator->target_sum =
         perturbator_evaluation * lagranges[0] + vanishing_polynomial_at_challenge * combiner_quotient_evaluation;
-    next_accumulator->gate_challenges = // note: known already in previous round
+    accumulator->gate_challenges = // note: known already in previous round
         update_gate_challenges(perturbator_challenge, accumulator->gate_challenges, deltas);
 
     // // Fold the commitments
     for (auto [combination, to_combine] :
-         zip_view(next_accumulator->vk->get_all(), keys_to_fold.get_precomputed_commitments())) {
+         zip_view(accumulator->vk->get_all(), keys_to_fold.get_precomputed_commitments())) {
         combination = batch_mul_native(to_combine, lagranges);
     }
     for (auto [combination, to_combine] :
-         zip_view(next_accumulator->witness_commitments.get_all(), keys_to_fold.get_witness_commitments())) {
+         zip_view(accumulator->witness_commitments.get_all(), keys_to_fold.get_witness_commitments())) {
         combination = batch_mul_native(to_combine, lagranges);
     }
 
     // Fold the relation parameters
-    for (auto [combination, to_combine] : zip_view(next_accumulator->alphas, keys_to_fold.get_alphas())) {
+    for (auto [combination, to_combine] : zip_view(accumulator->alphas, keys_to_fold.get_alphas())) {
         combination = linear_combination(to_combine, lagranges);
     }
     for (auto [combination, to_combine] :
-         zip_view(next_accumulator->relation_parameters.get_to_fold(), keys_to_fold.get_relation_parameters())) {
+         zip_view(accumulator->relation_parameters.get_to_fold(), keys_to_fold.get_relation_parameters())) {
         combination = linear_combination(to_combine, lagranges);
     }
 
-    return next_accumulator;
+    return accumulator;
 }
 
 template class ProtogalaxyVerifier_<DeciderVerificationKeys_<MegaFlavor, 2>>;

barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/oink_recursive_verifier.cpp

@@ -127,6 +127,7 @@ template <typename Flavor> void OinkRecursiveVerifier_<Flavor>::verify()
         RelationParameters<FF>{ eta, eta_two, eta_three, beta, gamma, public_input_delta };
     decider_vk->witness_commitments = std::move(commitments);
     decider_vk->alphas = std::move(alphas);
+    decider_vk->is_complete = true; // instance has been completely populated
 }
 
 template class OinkRecursiveVerifier_<bb::UltraRecursiveFlavor_<UltraCircuitBuilder>>;

barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.cpp

@@ -21,10 +21,9 @@ void ProtogalaxyRecursiveVerifier_<DeciderVerificationKeys>::run_oink_verifier_o
     transcript->load_proof(proof);
     auto key = keys_to_fold[0];
     auto domain_separator = std::to_string(0);
-    if (!key->is_accumulator) {
+    if (!key->is_complete) {
         OinkRecursiveVerifier_<Flavor> oink_verifier{ builder, key, transcript, domain_separator + '_' };
         oink_verifier.verify();
-        key->target_sum = 0;
         key->gate_challenges = std::vector<FF>(CONST_PG_LOG_N, 0);
     } else {
         // Fiat-Shamir the accumulator.
@@ -47,11 +46,13 @@ std::shared_ptr<typename DeciderVerificationKeys::DeciderVK> ProtogalaxyRecursiv
 {
     static constexpr size_t BATCHED_EXTENDED_LENGTH = DeciderVerificationKeys::BATCHED_EXTENDED_LENGTH;
     static constexpr size_t NUM_KEYS = DeciderVerificationKeys::NUM;
+    // The degree of the combiner quotient (K in the paper) is dk - k - 1 = k(d - 1) - 1.
+    // Hence we need  k(d - 1) evaluations to represent it.
     static constexpr size_t COMBINER_LENGTH = BATCHED_EXTENDED_LENGTH - NUM_KEYS;
 
     run_oink_verifier_on_each_incomplete_key(proof);
 
-    std::shared_ptr<DeciderVK> accumulator = keys_to_fold[0];
+    const std::shared_ptr<DeciderVK>& accumulator = keys_to_fold[0];
 
     // Perturbator round
     const FF delta = transcript->template get_challenge<FF>("delta");
@@ -66,9 +67,7 @@ std::shared_ptr<typename DeciderVerificationKeys::DeciderVK> ProtogalaxyRecursiv
     perturbator_coeffs[0] = accumulator->target_sum;
     const FF perturbator_evaluation = evaluate_perturbator(perturbator_coeffs, perturbator_challenge);
 
-    std::array<FF, COMBINER_LENGTH>
-        combiner_quotient_evals; // The degree of the combiner quotient (K in the paper) is dk - k - 1 = k(d - 1)
-                                 // - 1. Hence we need  k(d - 1) evaluations to represent it.
+    std::array<FF, COMBINER_LENGTH> combiner_quotient_evals;
     for (size_t idx = 0; idx < COMBINER_LENGTH; idx++) {
         combiner_quotient_evals[idx] =
             transcript->template receive_from_prover<FF>("combiner_quotient_" + std::to_string(idx + NUM_KEYS));
@@ -177,7 +176,6 @@ std::shared_ptr<typename DeciderVerificationKeys::DeciderVK> ProtogalaxyRecursiv
     output_sum.y.assert_equal(folded_sum.y);
 
     // Compute next folding parameters
-    accumulator->is_accumulator = true;
     accumulator->target_sum =
         perturbator_evaluation * lagranges[0] + vanishing_polynomial_at_challenge * combiner_quotient_at_challenge;
 

barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.test.cpp

@@ -234,7 +234,6 @@ class ProtogalaxyRecursiveTests : public testing::Test {
                                                      std::make_shared<typename InnerFoldingVerifier::Transcript>());
         native_folding_verifier.transcript->enable_manifest();
         std::shared_ptr<InnerDeciderVerificationKey> native_accumulator;
-        native_folding_verifier.verify_folding_proof(folding_proof.proof);
         for (size_t idx = 0; idx < num_verifiers; idx++) {
             native_accumulator = native_folding_verifier.verify_folding_proof(folding_proof.proof);
             if (idx < num_verifiers - 1) { // else the transcript is null in the test below

barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/recursive_decider_verification_key.hpp

@@ -36,7 +36,7 @@ template <IsRecursiveFlavor Flavor> class RecursiveDeciderVerificationKey_ {
 
     std::shared_ptr<VKAndHash> vk_and_hash;
 
-    bool is_accumulator = false;
+    bool is_complete = false; // whether this instance has been completely populated
 
     // An array {1, α₁, …, αₖ}, where k = NUM_SUBRELATIONS - 1.
     SubrelationSeparators alphas;
@@ -66,8 +66,8 @@ template <IsRecursiveFlavor Flavor> class RecursiveDeciderVerificationKey_ {
     RecursiveDeciderVerificationKey_(Builder* builder, std::shared_ptr<NativeDeciderVerificationKey> verification_key)
         : RecursiveDeciderVerificationKey_(builder, verification_key->vk)
     {
-        is_accumulator = verification_key->is_accumulator;
-        if (is_accumulator) {
+        is_complete = verification_key->is_complete;
+        if (is_complete) {
             for (size_t alpha_idx = 0; alpha_idx < Flavor::NUM_SUBRELATIONS - 1; alpha_idx++) {
                 alphas[alpha_idx] = FF::from_witness(builder, verification_key->alphas[alpha_idx]);
             }
@@ -117,7 +117,7 @@ template <IsRecursiveFlavor Flavor> class RecursiveDeciderVerificationKey_ {
         }
 
         NativeDeciderVerificationKey decider_vk(native_honk_vk);
-        decider_vk.is_accumulator = is_accumulator;
+        decider_vk.is_complete = is_complete;
 
         for (auto [alpha, inst_alpha] : zip_view(alphas, decider_vk.alphas)) {
             inst_alpha = alpha.get_value();

barretenberg/cpp/src/barretenberg/ultra_honk/decider_proving_key.hpp

@@ -55,12 +55,13 @@ template <IsUltraOrMegaHonk Flavor> class DeciderProvingKey_ {
     ProverPolynomials polynomials; // the multilinear polynomials used by the prover
     SubrelationSeparators alphas;  // a challenge for each subrelation
     bb::RelationParameters<FF> relation_parameters;
-    std::vector<FF> gate_challenges;
-    FF target_sum{ 0 }; // Sumcheck target sum; typically nonzero for a ProtogalaxyProver's accmumulator
+    std::vector<FF> gate_challenges = std::vector<FF>(CONST_PG_LOG_N, 0);
+    FF target_sum{ 0 }; // Sumcheck target sum; typically nonzero for a ProtogalaxyProver's accumulator
 
     HonkProof ipa_proof; // utilized only for UltraRollupFlavor
 
-    bool is_accumulator = false;
+    bool is_accumulator = false; // whether this instance the result of a Protogalaxy folding
+    bool is_complete = false;    // whether this instance has been completely populated
     std::vector<uint32_t> memory_read_records;
     std::vector<uint32_t> memory_write_records;
 

barretenberg/cpp/src/barretenberg/ultra_honk/decider_verification_key.hpp

@@ -30,12 +30,12 @@ template <IsUltraOrMegaHonk Flavor> class DeciderVerificationKey_ {
 
     std::shared_ptr<VerificationKey> vk;
 
-    bool is_accumulator = false;
+    bool is_complete = false; // whether this instance has been completely populated
 
     SubrelationSeparators alphas; // a challenge for each subrelation
     RelationParameters<FF> relation_parameters;
     std::vector<FF> gate_challenges;
-    // The target sum, which is typically nonzero for a ProtogalaxyProver's accmumulator
+    // The target sum, which is typically nonzero for a ProtogalaxyProver's accumulator
     FF target_sum{ 0 };
 
     WitnessCommitments witness_commitments;
@@ -83,6 +83,6 @@ template <IsUltraOrMegaHonk Flavor> class DeciderVerificationKey_ {
         return decider_vk_hash;
     }
 
-    MSGPACK_FIELDS(vk, relation_parameters, alphas, is_accumulator, gate_challenges, target_sum, witness_commitments);
+    MSGPACK_FIELDS(vk, relation_parameters, alphas, is_complete, gate_challenges, target_sum, witness_commitments);
 };
 } // namespace bb