feat: fix AVM circuit size (#16332)

Remove circuit size and num_public_inputs from AVM. Use the fixed AVM
size everywhere.

Author: lucasxia01

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

@@ -28,7 +28,6 @@ ClientIVC::ClientIVC(size_t num_circuits, TraceSettings trace_settings)
     size_t commitment_key_size =
         std::max(trace_settings.dyadic_size(), 1UL << TranslatorFlavor::CONST_TRANSLATOR_LOG_N);
     info("BN254 commitment key size: ", commitment_key_size);
-    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1420): pass commitment keys by value
     bn254_commitment_key = CommitmentKey<curve::BN254>(commitment_key_size);
 }
 
@@ -458,7 +457,6 @@ void ClientIVC::accumulate(ClientCircuit& circuit, const std::shared_ptr<MegaVer
     // If the current circuit overflows past the current size of the commitment key, reinitialize accordingly.
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/1319)
     if (proving_key->dyadic_size() > bn254_commitment_key.dyadic_size) {
-        // TODO(https://github.com/AztecProtocol/barretenberg/issues/1420): pass commitment keys by value
         bn254_commitment_key = CommitmentKey<curve::BN254>(proving_key->dyadic_size());
         goblin.commitment_key = bn254_commitment_key;
     }

barretenberg/cpp/src/barretenberg/dsl/acir_format/avm2_recursion_constraint.cpp

@@ -46,7 +46,6 @@ namespace {
  */
 void create_dummy_vkey_and_proof(Builder& builder,
                                  [[maybe_unused]] size_t proof_size,
-                                 size_t public_inputs_size,
                                  const std::vector<field_ct>& key_fields,
                                  const std::vector<field_ct>& proof_fields)
 {
@@ -70,27 +69,7 @@ void create_dummy_vkey_and_proof(Builder& builder,
         offset++;
     };
 
-    // Relevant source for proof layout: AvmFlavor::Transcript::serialize_full_transcript()
-    // TODO(#13390): Revive this assertion (and remove the >= 0 one) once we freeze the number of colums in AVM.
-    // assert((proof_size - Flavor::NUM_WITNESS_ENTITIES * Flavor::NUM_FRS_COM -
-    //         (Flavor::NUM_ALL_ENTITIES + 1) * Flavor::NUM_FRS_FR - Flavor::NUM_FRS_COM) %
-    //            (Flavor::NUM_FRS_COM + Flavor::NUM_FRS_FR * (Flavor::BATCHED_RELATION_PARTIAL_LENGTH + 1)) ==
-    //        0);
-
-    // Derivation of circuit size based on the proof
-    // TODO#13390): Revive the following code once we freeze the number of colums in AVM.
-    // const auto log_circuit_size =
-    //     (proof_size - Flavor::NUM_WITNESS_ENTITIES * Flavor::NUM_FRS_COM -
-    //      (Flavor::NUM_ALL_ENTITIES + 1) * Flavor::NUM_FRS_FR - Flavor::NUM_FRS_COM) /
-    //     (Flavor::NUM_FRS_COM + Flavor::NUM_FRS_FR * (Flavor::BATCHED_RELATION_PARTIAL_LENGTH + 1));
-    const auto log_circuit_size = numeric::get_msb(avm2::CIRCUIT_SUBGROUP_SIZE);
-
-    // First key field is log circuit size
-    builder.set_variable(key_fields[0].witness_index, log_circuit_size);
-    // Second key field is number of public inputs
-    builder.set_variable(key_fields[1].witness_index, public_inputs_size);
-
-    size_t offset = 2;
+    size_t offset = 0;
     for (size_t i = 0; i < Flavor::NUM_PRECOMPUTED_ENTITIES; ++i) {
         set_dummy_commitment(key_fields, offset);
     }
@@ -106,7 +85,7 @@ void create_dummy_vkey_and_proof(Builder& builder,
     }
 
     // now the univariates
-    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N * Flavor::BATCHED_RELATION_PARTIAL_LENGTH; i++) {
+    for (size_t i = 0; i < avm2::MAX_AVM_TRACE_LOG_SIZE * Flavor::BATCHED_RELATION_PARTIAL_LENGTH; i++) {
         set_dummy_evaluation_in_proof_fields(offset);
     }
 
@@ -116,12 +95,12 @@ void create_dummy_vkey_and_proof(Builder& builder,
     }
 
     // now the gemini fold commitments which are CONST_PROOF_SIZE_LOG_N - 1
-    for (size_t i = 1; i < CONST_PROOF_SIZE_LOG_N; i++) {
+    for (size_t i = 1; i < avm2::MAX_AVM_TRACE_LOG_SIZE; i++) {
         set_dummy_commitment(proof_fields, offset);
     }
 
     // the gemini fold evaluations which are CONST_PROOF_SIZE_LOG_N
-    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N; i++) {
+    for (size_t i = 0; i < avm2::MAX_AVM_TRACE_LOG_SIZE; i++) {
         set_dummy_evaluation_in_proof_fields(offset);
     }
 
@@ -160,7 +139,7 @@ HonkRecursionConstraintOutput<Builder> create_avm2_recursion_constraints_goblin(
 
     // Populate the key fields and proof fields with dummy values to prevent issues (e.g. points must be on curve).
     if (!has_valid_witness_assignments) {
-        create_dummy_vkey_and_proof(builder, input.proof.size(), input.public_inputs.size(), key_fields, proof_fields);
+        create_dummy_vkey_and_proof(builder, input.proof.size(), key_fields, proof_fields);
     }
 
     // Execute the Goblin AVM2 recursive verifier

barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base_impl.hpp

@@ -236,8 +236,8 @@ template <typename FF_> void CircuitBuilderBase<FF_>::failure(std::string msg)
 {
 #ifndef FUZZING_DISABLE_WARNINGS
     if (!has_dummy_witnesses) {
-        // We have a builder failure when we have real witnesses which is a mistake.
-        info("(Experimental) WARNING: Builder failure when we have real witnesses!"); // not a catch-all error
+        // Not a catch-all error log. We have a builder failure when we have real witnesses which is a mistake.
+        info("(Experimental) WARNING: Builder failure when we have real witnesses! Ignore if writing vk.");
     }
 #endif
     _failed = true;

barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp

@@ -322,7 +322,6 @@ template <typename Flavor> class SumcheckProver {
         CommitmentKey ck;
 
         if constexpr (IsGrumpkinFlavor<Flavor>) {
-            // TODO(https://github.com/AztecProtocol/barretenberg/issues/1420): pass commitment keys by value
             ck = CommitmentKey(BATCHED_RELATION_PARTIAL_LENGTH);
             // Compute the vector {0, 1, \ldots, BATCHED_RELATION_PARTIAL_LENGTH-1} needed to transform the round
             // univariates from Lagrange to monomial basis

barretenberg/cpp/src/barretenberg/vm2/common/constants.hpp

@@ -6,7 +6,8 @@
 
 namespace bb::avm2 {
 
-constexpr uint32_t CIRCUIT_SUBGROUP_SIZE = 1 << 21;
+constexpr size_t MAX_AVM_TRACE_LOG_SIZE = 21;
+constexpr size_t MAX_AVM_TRACE_SIZE = 1 << MAX_AVM_TRACE_LOG_SIZE;
 
 // Also used for op_id in the circuit trace
 enum class BitwiseOperation : uint8_t {

barretenberg/cpp/src/barretenberg/vm2/constraining/flavor.cpp

@@ -18,25 +18,24 @@ AvmFlavor::ProverPolynomials::ProverPolynomials(ProvingKey& proving_key)
 void AvmFlavor::Transcript::deserialize_full_transcript()
 {
     size_t num_frs_read = 0;
-    circuit_size = deserialize_from_buffer<uint32_t>(proof_data, num_frs_read);
 
     for (auto& commitment : commitments) {
         commitment = deserialize_from_buffer<Commitment>(proof_data, num_frs_read);
     }
 
-    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N; ++i) {
+    for (size_t i = 0; i < log_circuit_size; ++i) {
         sumcheck_univariates.emplace_back(deserialize_from_buffer<bb::Univariate<FF, BATCHED_RELATION_PARTIAL_LENGTH>>(
             Transcript::proof_data, num_frs_read));
     }
 
     sumcheck_evaluations =
         deserialize_from_buffer<std::array<FF, NUM_ALL_ENTITIES>>(Transcript::proof_data, num_frs_read);
 
-    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N - 1; ++i) {
+    for (size_t i = 0; i < log_circuit_size - 1; ++i) {
         gemini_fold_comms.push_back(deserialize_from_buffer<Commitment>(proof_data, num_frs_read));
     }
 
-    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N; ++i) {
+    for (size_t i = 0; i < log_circuit_size; ++i) {
         gemini_fold_evals.push_back(deserialize_from_buffer<FF>(proof_data, num_frs_read));
     }
 
@@ -50,23 +49,21 @@ void AvmFlavor::Transcript::serialize_full_transcript()
     size_t old_proof_length = proof_data.size();
     Transcript::proof_data.clear();
 
-    serialize_to_buffer(circuit_size, Transcript::proof_data);
-
     for (const auto& commitment : commitments) {
         serialize_to_buffer(commitment, Transcript::proof_data);
     }
 
-    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N; ++i) {
+    for (size_t i = 0; i < log_circuit_size; ++i) {
         serialize_to_buffer(sumcheck_univariates[i], Transcript::proof_data);
     }
 
     serialize_to_buffer(sumcheck_evaluations, Transcript::proof_data);
 
-    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N - 1; ++i) {
+    for (size_t i = 0; i < log_circuit_size - 1; ++i) {
         serialize_to_buffer(gemini_fold_comms[i], proof_data);
     }
 
-    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N; ++i) {
+    for (size_t i = 0; i < log_circuit_size; ++i) {
         serialize_to_buffer(gemini_fold_evals[i], proof_data);
     }
 
@@ -95,12 +92,8 @@ AvmFlavor::PartiallyEvaluatedMultivariates::PartiallyEvaluatedMultivariates(cons
     }
 }
 
-AvmFlavor::ProvingKey::ProvingKey(const size_t circuit_size, const size_t num_public_inputs)
-    : circuit_size(circuit_size)
-    , log_circuit_size(numeric::get_msb(circuit_size))
-    , num_public_inputs(num_public_inputs)
-    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1420): pass commitment keys by value
-    , commitment_key(circuit_size + 1) {
+AvmFlavor::ProvingKey::ProvingKey()
+    : commitment_key(circuit_size + 1) {
         // The proving key's polynomials are not allocated here because they are later overwritten
         // AvmComposer::compute_witness(). We should probably refactor this flow.
     };
@@ -112,7 +105,7 @@ AvmFlavor::ProvingKey::ProvingKey(const size_t circuit_size, const size_t num_pu
  */
 std::vector<AvmFlavor::FF> AvmFlavor::VerificationKey::to_field_elements() const
 {
-    std::vector<FF> elements = { FF(log_circuit_size), FF(num_public_inputs) };
+    std::vector<FF> elements;
 
     for (auto const& comm : get_all()) {
         std::vector<FF> comm_as_fields = field_conversion::convert_to_bn254_frs(comm);

barretenberg/cpp/src/barretenberg/vm2/constraining/flavor.hpp

@@ -13,6 +13,7 @@
 #include "barretenberg/transcript/transcript.hpp"
 
 #include "barretenberg/vm2/common/aztec_constants.hpp"
+#include "barretenberg/vm2/common/constants.hpp"
 #include "barretenberg/vm2/constraining/entities.hpp"
 #include "barretenberg/vm2/constraining/flavor_settings.hpp"
 
@@ -102,7 +103,7 @@ class AvmFlavor {
     // to see its value and then update `AVM_V2_PROOF_LENGTH_IN_FIELDS` in constants.nr.
     static constexpr size_t COMPUTED_AVM_PROOF_LENGTH_IN_FIELDS =
         (NUM_WITNESS_ENTITIES + 1) * NUM_FRS_COM + (NUM_ALL_ENTITIES + 1) * NUM_FRS_FR +
-        CONST_PROOF_SIZE_LOG_N * (NUM_FRS_COM + NUM_FRS_FR * (BATCHED_RELATION_PARTIAL_LENGTH + 1));
+        MAX_AVM_TRACE_LOG_SIZE * (NUM_FRS_COM + NUM_FRS_FR * (BATCHED_RELATION_PARTIAL_LENGTH + 1));
 
     static_assert(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED >= COMPUTED_AVM_PROOF_LENGTH_IN_FIELDS,
                   "\n The constant AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED is now too short\n"
@@ -197,7 +198,7 @@ class AvmFlavor {
 
     class Transcript : public NativeTranscript {
       public:
-        uint32_t circuit_size;
+        size_t log_circuit_size = MAX_AVM_TRACE_LOG_SIZE;
 
         std::array<Commitment, NUM_WITNESS_ENTITIES> commitments;
 
@@ -219,18 +220,13 @@ class AvmFlavor {
         using FF = typename Polynomial::FF;
         DEFINE_COMPOUND_GET_ALL(PrecomputedEntities<Polynomial>, WitnessEntities<Polynomial>);
 
-        ProvingKey() = default;
-        ProvingKey(const size_t circuit_size, const size_t num_public_inputs);
+        size_t circuit_size = MAX_AVM_TRACE_SIZE; // Fixed size
+        size_t log_circuit_size = MAX_AVM_TRACE_LOG_SIZE;
 
-        size_t circuit_size = 0;
-        size_t log_circuit_size = 0;
-        size_t num_public_inputs = 0;
+        ProvingKey();
 
         CommitmentKey commitment_key;
 
-        // Offset off the public inputs from the start of the execution trace
-        size_t pub_inputs_offset = 0;
-
         // The number of public inputs has to be the same for all instances because they are
         // folded element by element.
         std::vector<FF> public_inputs;
@@ -248,19 +244,17 @@ class AvmFlavor {
         VerificationKey() = default;
 
         VerificationKey(const std::shared_ptr<ProvingKey>& proving_key)
-            : NativeVerificationKey_(proving_key->circuit_size, static_cast<size_t>(proving_key->num_public_inputs))
         {
+            this->log_circuit_size = MAX_AVM_TRACE_LOG_SIZE;
             for (auto [polynomial, commitment] :
                  zip_view(proving_key->get_precomputed_polynomials(), this->get_all())) {
                 commitment = proving_key->commitment_key.commit(polynomial);
             }
         }
 
-        VerificationKey(const size_t circuit_size,
-                        const size_t num_public_inputs,
-                        std::array<Commitment, NUM_PRECOMPUTED_COMMITMENTS> const& precomputed_cmts)
-            : NativeVerificationKey_(circuit_size, num_public_inputs)
+        VerificationKey(std::array<Commitment, NUM_PRECOMPUTED_COMMITMENTS> const& precomputed_cmts)
         {
+            this->log_circuit_size = MAX_AVM_TRACE_LOG_SIZE;
             for (auto [vk_cmt, cmt] : zip_view(this->get_all(), precomputed_cmts)) {
                 vk_cmt = cmt;
             }

barretenberg/cpp/src/barretenberg/vm2/constraining/polynomials.cpp

@@ -29,7 +29,7 @@ AvmProver::ProverPolynomials compute_polynomials(tracegen::TraceContainer& trace
 
                            poly = AvmProver::Polynomial(
                                /*memory size*/ allocated_size,
-                               /*largest possible index*/ CIRCUIT_SUBGROUP_SIZE,
+                               /*largest possible index*/ MAX_AVM_TRACE_SIZE, // TODO(#16660): use real size?
                                /*make shiftable with offset*/ 1);
                        }
                    }));
@@ -55,7 +55,7 @@ AvmProver::ProverPolynomials compute_polynomials(tracegen::TraceContainer& trace
                            // WARNING! Column-Polynomials order matters!
                            Column col = static_cast<Column>(i);
                            const auto num_rows = trace.get_column_rows(col);
-                           poly = AvmProver::Polynomial::create_non_parallel_zero_init(num_rows, CIRCUIT_SUBGROUP_SIZE);
+                           poly = AvmProver::Polynomial::create_non_parallel_zero_init(num_rows, MAX_AVM_TRACE_SIZE);
                        });
                    }));
 

barretenberg/cpp/src/barretenberg/vm2/constraining/prover.cpp

@@ -9,6 +9,7 @@
 #include "barretenberg/honk/proof_system/logderivative_library.hpp"
 #include "barretenberg/relations/permutation_relation.hpp"
 #include "barretenberg/sumcheck/sumcheck.hpp"
+#include "barretenberg/vm2/common/constants.hpp"
 #include "barretenberg/vm2/tooling/stats.hpp"
 
 namespace bb::avm2 {
@@ -107,15 +108,15 @@ void AvmProver::execute_relation_check_rounds()
 
     // Generate gate challenges
     std::vector<FF> gate_challenges =
-        transcript->template get_powers_of_challenge<FF>("Sumcheck:gate_challenge", CONST_PROOF_SIZE_LOG_N);
+        transcript->template get_powers_of_challenge<FF>("Sumcheck:gate_challenge", key->log_circuit_size);
 
     Sumcheck sumcheck(key->circuit_size,
                       prover_polynomials,
                       transcript,
                       alpha,
                       gate_challenges,
                       relation_parameters,
-                      CONST_PROOF_SIZE_LOG_N);
+                      key->log_circuit_size);
 
     sumcheck_output = sumcheck.prove();
 }

barretenberg/cpp/src/barretenberg/vm2/constraining/recursion/recursive_flavor.hpp

@@ -63,11 +63,9 @@ class AvmRecursiveFlavor {
     class VerificationKey
         : public StdlibVerificationKey_<CircuitBuilder, NativeFlavor::PrecomputedEntities<Commitment>> {
       public:
+        size_t log_fixed_circuit_size = MAX_AVM_TRACE_LOG_SIZE;
         VerificationKey(CircuitBuilder* builder, const std::shared_ptr<NativeVerificationKey>& native_key)
         {
-            this->log_circuit_size = FF::from_witness(builder, native_key->log_circuit_size);
-            this->num_public_inputs = FF::from_witness(builder, native_key->num_public_inputs);
-
             for (auto [native_comm, comm] : zip_view(native_key->get_all(), this->get_all())) {
                 comm = Commitment::from_witness(builder, native_comm);
             }
@@ -82,16 +80,8 @@ class AvmRecursiveFlavor {
         VerificationKey(CircuitBuilder& builder, std::span<const FF> elements)
         {
             size_t num_frs_read = 0;
-            size_t num_frs_FF = stdlib::field_conversion::calc_num_bn254_frs<CircuitBuilder, FF>();
             size_t num_frs_Comm = stdlib::field_conversion::calc_num_bn254_frs<CircuitBuilder, Commitment>();
 
-            this->log_circuit_size = stdlib::field_conversion::convert_from_bn254_frs<CircuitBuilder, FF>(
-                builder, elements.subspan(num_frs_read, num_frs_FF));
-            num_frs_read += num_frs_FF;
-            this->num_public_inputs = stdlib::field_conversion::convert_from_bn254_frs<CircuitBuilder, FF>(
-                builder, elements.subspan(num_frs_read, num_frs_FF));
-            num_frs_read += num_frs_FF;
-
             for (Commitment& comm : this->get_all()) {
                 comm = stdlib::field_conversion::convert_from_bn254_frs<CircuitBuilder, Commitment>(
                     builder, elements.subspan(num_frs_read, num_frs_Comm));