fix: deprecate witness circuit size from ECCVM and Translator

barretenberg/cpp/src/barretenberg/api/api_client_ivc.cpp

@@ -304,7 +304,7 @@ bool ClientIVCAPI::verify([[maybe_unused]] const Flags& flags,
 
     vk.mega->pcs_verification_key = std::make_shared<VerifierCommitmentKey<curve::BN254>>();
     vk.eccvm->pcs_verification_key =
-        std::make_shared<VerifierCommitmentKey<curve::Grumpkin>>(vk.eccvm->circuit_size + 1);
+        std::make_shared<VerifierCommitmentKey<curve::Grumpkin>>((1UL << CONST_ECCVM_LOG_N) + 1);
     vk.translator->pcs_verification_key = std::make_shared<VerifierCommitmentKey<curve::BN254>>();
 
     const bool verified = ClientIVC::verify(proof, vk);

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

@@ -33,7 +33,7 @@ void prove_tube(const std::string& output_path, const std::string& vk_path)
     // We don't serialise and deserialise the Grumkin SRS so initialise with circuit_size + 1 to be able to recursively
     // verify IPA. The + 1 is to satisfy IPA verification key requirements.
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/1025)
-    vk.eccvm->pcs_verification_key = std::make_shared<GrumpkinVk>(vk.eccvm->circuit_size + 1);
+    vk.eccvm->pcs_verification_key = std::make_shared<GrumpkinVk>((1UL << CONST_ECCVM_LOG_N) + 1);
 
     auto builder = std::make_shared<Builder>();
 

barretenberg/cpp/src/barretenberg/commitment_schemes/gemini/gemini.hpp

@@ -360,6 +360,8 @@ template <typename Curve> class GeminiVerifier_ {
     {
         const size_t log_n = multilinear_challenge.size();
         const bool has_interleaved = claim_batcher.interleaved.has_value();
+        // GeminiVerifier is only used in tests, so no padding required.
+        static constexpr bool use_padding = false;
 
         const Fr rho = transcript->template get_challenge<Fr>("rho");
 
@@ -444,7 +446,7 @@ template <typename Curve> class GeminiVerifier_ {
         }
 
         // Compute the evaluations  Aₗ(r^{2ˡ}) for l = 0, ..., m-1
-        std::vector<Fr> gemini_fold_pos_evaluations = compute_fold_pos_evaluations(
+        std::vector<Fr> gemini_fold_pos_evaluations = compute_fold_pos_evaluations<use_padding>(
             log_n, batched_evaluation, multilinear_challenge, r_squares, evaluations, p_neg);
         // Extract the evaluation A₀(r) = A₀₊(r) + P₊(r^s)
         auto full_a_0_pos = gemini_fold_pos_evaluations[0];
@@ -538,6 +540,7 @@ template <typename Curve> class GeminiVerifier_ {
      * @param fold_neg_evals  Evaluations \f$ A_{i-1}(-r^{2^{i-1}}) \f$.
      * @return Evaluation \f$ A_0(r) \f$.
      */
+    template <bool use_padding>
     static std::vector<Fr> compute_fold_pos_evaluations(
         const size_t log_n,
         const Fr& batched_evaluation,
@@ -550,7 +553,7 @@ template <typename Curve> class GeminiVerifier_ {
 
         Fr eval_pos_prev = batched_evaluation;
         // Virtual size allows padding in Shplemini.
-        const size_t virtual_log_n = evaluation_point.size();
+        const size_t virtual_log_n = use_padding ? evaluation_point.size() : log_n;
 
         Fr zero{ 0 };
         if constexpr (Curve::is_stdlib_type) {
@@ -576,24 +579,28 @@ template <typename Curve> class GeminiVerifier_ {
             Fr eval_pos = ((challenge_power * eval_pos_prev * 2) - eval_neg * (challenge_power * (Fr(1) - u) - u));
             // Divide by the denominator
             eval_pos *= (challenge_power * (Fr(1) - u) + u).invert();
-
-            if constexpr (Curve::is_stdlib_type) {
-                auto builder = evaluation_point[0].get_context();
-                // TODO(https://github.com/AztecProtocol/barretenberg/issues/1114): insecure dummy_round derivation!
-                stdlib::bool_t dummy_round = stdlib::witness_t(builder, l > log_n);
-                // If current index is bigger than log_n, we propagate `batched_evaluation` to the next
-                // round.  Otherwise, current `eval_pos` A₍ₗ₋₁₎(−r²⁽ˡ⁻¹⁾) becomes `eval_pos_prev` in the round l-2.
-                eval_pos_prev = Fr::conditional_assign(dummy_round, eval_pos_prev, eval_pos);
-                // If current index is bigger than log_n, we emplace 0, which is later multiplied against
-                // Commitment::one().
-                value_to_emplace = Fr::conditional_assign(dummy_round, zero, eval_pos_prev);
-
+            if constexpr (use_padding) {
+                if constexpr (Curve::is_stdlib_type) {
+                    auto builder = evaluation_point[0].get_context();
+                    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1114): insecure dummy_round derivation!
+                    stdlib::bool_t dummy_round = stdlib::witness_t(builder, l > log_n);
+                    // If current index is bigger than log_n, we propagate `batched_evaluation` to the next
+                    // round.  Otherwise, current `eval_pos` A₍ₗ₋₁₎(−r²⁽ˡ⁻¹⁾) becomes `eval_pos_prev` in the round l-2.
+                    eval_pos_prev = Fr::conditional_assign(dummy_round, eval_pos_prev, eval_pos);
+                    // If current index is bigger than log_n, we emplace 0, which is later multiplied against
+                    // Commitment::one().
+                    value_to_emplace = Fr::conditional_assign(dummy_round, zero, eval_pos_prev);
+
+                } else {
+                    // Perform the same logic natively
+                    bool dummy_round = l > log_n;
+                    eval_pos_prev = dummy_round ? eval_pos_prev : eval_pos;
+                    value_to_emplace = dummy_round ? zero : eval_pos_prev;
+                };
             } else {
-                // Perform the same logic natively
-                bool dummy_round = l > log_n;
-                eval_pos_prev = dummy_round ? eval_pos_prev : eval_pos;
-                value_to_emplace = dummy_round ? zero : eval_pos_prev;
-            };
+                eval_pos_prev = eval_pos;
+                value_to_emplace = eval_pos_prev;
+            }
             fold_pos_evaluations.emplace_back(value_to_emplace);
         }
 

barretenberg/cpp/src/barretenberg/commitment_schemes/ipa/ipa.test.cpp

@@ -11,6 +11,8 @@ using Curve = curve::Grumpkin;
 
 class IPATest : public CommitmentTest<Curve> {
   public:
+    static constexpr bool USE_PADDING = false;
+
     using Fr = typename Curve::ScalarField;
     using GroupElement = typename Curve::Element;
     using CK = CommitmentKey<Curve>;
@@ -23,7 +25,7 @@ class IPATest : public CommitmentTest<Curve> {
     using ShplonkVerifier = ShplonkVerifier_<Curve>;
     using GeminiProver = GeminiProver_<Curve>;
     using GeminiVerifier = GeminiVerifier_<Curve>;
-    using ShpleminiVerifier = ShpleminiVerifier_<Curve>;
+    using ShpleminiVerifier = ShpleminiVerifier_<Curve, USE_PADDING>;
     using ClaimBatcher = ClaimBatcher_<Curve>;
     using ClaimBatch = ClaimBatcher::Batch;
 
@@ -304,7 +306,7 @@ TEST_F(IPATest, ShpleminiIPAWithShift)
     auto verifier_transcript = NativeTranscript::verifier_init_empty(prover_transcript);
 
     const auto batch_opening_claim = ShpleminiVerifier::compute_batch_opening_claim(
-        small_n, mock_claims.claim_batcher, mle_opening_point, vk->get_g1_identity(), verifier_transcript);
+        small_log_n, mock_claims.claim_batcher, mle_opening_point, vk->get_g1_identity(), verifier_transcript);
 
     auto result = PCS::reduce_verify_batch_opening_claim(batch_opening_claim, vk, verifier_transcript);
     // auto result = PCS::reduce_verify(vk, shplonk_verifier_claim, verifier_transcript);
@@ -355,7 +357,7 @@ TEST_F(IPATest, ShpleminiIPAShiftsRemoval)
     // vectors corresponding to the "shifted" commitment
     auto verifier_transcript = NativeTranscript::verifier_init_empty(prover_transcript);
 
-    const auto batch_opening_claim = ShpleminiVerifier::compute_batch_opening_claim(small_n,
+    const auto batch_opening_claim = ShpleminiVerifier::compute_batch_opening_claim(small_log_n,
                                                                                     mock_claims.claim_batcher,
                                                                                     mle_opening_point,
                                                                                     vk->get_g1_identity(),

barretenberg/cpp/src/barretenberg/commitment_schemes/kzg/kzg.test.cpp

@@ -10,6 +10,7 @@ using Curve = curve::BN254;
 
 class KZGTest : public CommitmentTest<Curve> {
   public:
+    static constexpr bool USE_PADDING = true;
     using Fr = typename Curve::ScalarField;
     using Commitment = typename Curve::AffineElement;
     using PCS = KZG<curve::BN254>;
@@ -18,7 +19,7 @@ class KZGTest : public CommitmentTest<Curve> {
     using ShplonkVerifier = ShplonkVerifier_<Curve>;
     using GeminiProver = GeminiProver_<Curve>;
     using GeminiVerifier = GeminiVerifier_<Curve>;
-    using ShpleminiVerifier = ShpleminiVerifier_<Curve>;
+    using ShpleminiVerifier = ShpleminiVerifier_<Curve, USE_PADDING>;
 
     static constexpr size_t n = 16;
     static constexpr size_t log_n = 4;
@@ -191,7 +192,7 @@ TEST_F(KZGTest, ShpleminiKzgWithShift)
     // Gemini verifier output:
     // - claim: d+1 commitments to Fold_{r}^(0), Fold_{-r}^(0), Fold^(l), d+1 evaluations a_0_pos, a_l, l = 0:d-1
     const auto batch_opening_claim = ShpleminiVerifier::compute_batch_opening_claim(
-        n, mock_claims.claim_batcher, mle_opening_point, vk->get_g1_identity(), verifier_transcript);
+        log_n, mock_claims.claim_batcher, mle_opening_point, vk->get_g1_identity(), verifier_transcript);
 
     const auto pairing_points = PCS::reduce_verify_batch_opening_claim(batch_opening_claim, verifier_transcript);
     // Final pairing check: e([Q] - [Q_z] + z[W], [1]_2) = e([W], [x]_2)
@@ -238,7 +239,7 @@ TEST_F(KZGTest, ShpleminiKzgWithShiftAndInterleaving)
 
     // Gemini verifier output:
     // - claim: d+1 commitments to Fold_{r}^(0), Fold_{-r}^(0), Fold^(l), d+1 evaluations a_0_pos, a_l, l = 0:d-1
-    const auto batch_opening_claim = ShpleminiVerifier::compute_batch_opening_claim(n,
+    const auto batch_opening_claim = ShpleminiVerifier::compute_batch_opening_claim(log_n,
                                                                                     mock_claims.claim_batcher,
                                                                                     mle_opening_point,
                                                                                     vk->get_g1_identity(),
@@ -305,7 +306,7 @@ TEST_F(KZGTest, ShpleminiKzgShiftsRemoval)
 
     // Gemini verifier output:
     // - claim: d+1 commitments to Fold_{r}^(0), Fold_{-r}^(0), Fold^(l), d+1 evaluations a_0_pos, a_l, l = 0:d-1
-    const auto batch_opening_claim = ShpleminiVerifier::compute_batch_opening_claim(n,
+    const auto batch_opening_claim = ShpleminiVerifier::compute_batch_opening_claim(log_n,
                                                                                     mock_claims.claim_batcher,
                                                                                     mle_opening_point,
                                                                                     vk->get_g1_identity(),

barretenberg/cpp/src/barretenberg/commitment_schemes/shplonk/shplemini.hpp

@@ -180,7 +180,7 @@ template <typename Curve> class ShpleminiProver_ {
  *
  */
 
-template <typename Curve> class ShpleminiVerifier_ {
+template <typename Curve, bool use_padding> class ShpleminiVerifier_ {
     using Fr = typename Curve::ScalarField;
     using GroupElement = typename Curve::Element;
     using Commitment = typename Curve::AffineElement;
@@ -192,7 +192,7 @@ template <typename Curve> class ShpleminiVerifier_ {
   public:
     template <typename Transcript>
     static BatchOpeningClaim<Curve> compute_batch_opening_claim(
-        const Fr N,
+        const size_t log_n,
         ClaimBatcher& claim_batcher,
         const std::vector<Fr>& multivariate_challenge,
         const Commitment& g1_identity,
@@ -209,14 +209,6 @@ template <typename Curve> class ShpleminiVerifier_ {
     {
         const bool committed_sumcheck = !sumcheck_round_evaluations.empty();
 
-        // Extract log_n
-        size_t log_n{ 0 };
-        if constexpr (Curve::is_stdlib_type) {
-            log_n = numeric::get_msb(static_cast<uint32_t>(N.get_value()));
-        } else {
-            log_n = numeric::get_msb(static_cast<uint32_t>(N));
-        }
-
         // When padding is enabled, the size of the multilinear challenge may be bigger than the log of `circuit_size`.
         const size_t virtual_log_n = multivariate_challenge.size();
 
@@ -345,12 +337,12 @@ template <typename Curve> class ShpleminiVerifier_ {
         // Reconstruct Aᵢ(r²ⁱ) for i=0, ..., d - 1 from the batched evaluation of the multilinear polynomials and
         // Aᵢ(−r²ⁱ) for i = 0, ..., d - 1. In the case of interleaving, we compute A₀(r) as A₀₊(r) + P₊(r^s).
         const std::vector<Fr> gemini_fold_pos_evaluations =
-            GeminiVerifier_<Curve>::compute_fold_pos_evaluations(log_n,
-                                                                 batched_evaluation,
-                                                                 multivariate_challenge,
-                                                                 gemini_eval_challenge_powers,
-                                                                 gemini_fold_neg_evaluations,
-                                                                 p_neg);
+            GeminiVerifier_<Curve>::template compute_fold_pos_evaluations<use_padding>(log_n,
+                                                                                       batched_evaluation,
+                                                                                       multivariate_challenge,
+                                                                                       gemini_eval_challenge_powers,
+                                                                                       gemini_fold_neg_evaluations,
+                                                                                       p_neg);
 
         // Place the commitments to Gemini fold polynomials Aᵢ in the vector of batch_mul commitments, compute the
         // contributions from Aᵢ(−r²ⁱ) for i=1, … , d − 1 to the constant term accumulator, add corresponding scalars
@@ -464,7 +456,7 @@ template <typename Curve> class ShpleminiVerifier_ {
                                                          std::vector<Fr>& scalars,
                                                          Fr& constant_term_accumulator)
     {
-        const size_t virtual_log_n = gemini_neg_evaluations.size();
+        const size_t virtual_log_n = use_padding ? gemini_neg_evaluations.size() : log_n;
         // TODO(https://github.com/AztecProtocol/barretenberg/issues/1159): Decouple constants from primitives.
         // Start from 1, because the commitment to A_0 is reconstructed from the commitments to the multilinear
         // polynomials. The corresponding evaluations are also handled separately.
@@ -484,17 +476,19 @@ template <typename Curve> class ShpleminiVerifier_ {
             constant_term_accumulator +=
                 scaling_factor_neg * gemini_neg_evaluations[j] + scaling_factor_pos * gemini_pos_evaluations[j];
 
-            if constexpr (Curve::is_stdlib_type) {
-                auto builder = gemini_neg_evaluations[0].get_context();
-                // TODO(https://github.com/AztecProtocol/barretenberg/issues/1114): insecure!
-                stdlib::bool_t dummy_round = stdlib::witness_t(builder, j >= log_n);
-                Fr zero = Fr(0);
-                scaling_factor_neg = Fr::conditional_assign(dummy_round, zero, scaling_factor_neg);
-                scaling_factor_pos = Fr::conditional_assign(dummy_round, zero, scaling_factor_pos);
-            } else {
-                if (j >= log_n) {
-                    scaling_factor_neg = 0;
-                    scaling_factor_pos = 0;
+            if constexpr (use_padding) {
+                if constexpr (Curve::is_stdlib_type) {
+                    auto builder = gemini_neg_evaluations[0].get_context();
+                    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1114): insecure!
+                    stdlib::bool_t dummy_round = stdlib::witness_t(builder, j >= log_n);
+                    Fr zero = Fr(0);
+                    scaling_factor_neg = Fr::conditional_assign(dummy_round, zero, scaling_factor_neg);
+                    scaling_factor_pos = Fr::conditional_assign(dummy_round, zero, scaling_factor_pos);
+                } else {
+                    if (j >= log_n) {
+                        scaling_factor_neg = 0;
+                        scaling_factor_pos = 0;
+                    }
                 }
             }
             // Place the scaling factor to the 'scalars' vector