I fixed the size of the op queue

Author: maramihali

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

@@ -269,6 +269,10 @@ ClientIVC::perform_recursive_verification_and_databus_consistency_checks(
     pairing_points.aggregate(nested_pairing_points);
     if (is_hiding_kernel) {
         pairing_points.aggregate(decider_pairing_points);
+        // Placeholder for randomness (will be removed)
+        circuit.queue_ecc_no_op();
+        circuit.queue_ecc_no_op();
+        info("num ops in hiding kernel ", circuit.op_queue->get_unmerged_subtable_size());
     }
 
     return { output_verifier_accumulator, pairing_points, merged_table_commitments };
@@ -312,6 +316,8 @@ void ClientIVC::complete_kernel_circuit_logic(ClientCircuit& circuit)
     // subtable is at the top of the final aggregate table since it is the last to be prepended).
     if (is_tail_kernel) {
         circuit.queue_ecc_no_op();
+        circuit.queue_ecc_no_op();
+        circuit.queue_ecc_no_op();
     }
     circuit.queue_ecc_eq();
 

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

@@ -88,7 +88,6 @@ TEST_F(ClientIVCTests, BasicStructured)
 
     EXPECT_TRUE(ClientIVC::verify(proof, vk));
 };
-
 /**
  * @brief Check that the IVC fails if an intermediate fold proof is invalid
  * @details When accumulating 4 circuits, there are 3 fold proofs to verify (the first two are recursively verfied and

barretenberg/cpp/src/barretenberg/goblin/goblin.cpp

@@ -45,14 +45,31 @@ void Goblin::prove_translator()
     auto translator_key = std::make_shared<TranslatorProvingKey>(translator_builder, commitment_key);
     TranslatorProver translator_prover(translator_key, transcript);
     goblin_proof.translator_proof = translator_prover.construct_proof();
+    // auto op = op_queue->construct_ultra_ops_table_columns()[0];
+    // auto op_translator = op_queue->get_ultra_ops();
+    // info(op.size(), " ", op_translator.size());
+    // for (size_t i = 0; i < op_translator.size(); i++) {}
+
+    //     if
+    // info(op.size(), " ", translator_key->proving_key->polynomials.op.size());
+    // for (size_t i = 0; i < op.size(); i++) {
+    //     if (op.at(i) != translator_key->proving_key->polynomials.op[i]) {
+    //         info("mismatch at ",
+    //              i,
+    //              " op_queue: ",
+    //              op.at(i),
+    //              " translator_key: ",
+    //              translator_key->proving_key->polynomials.op[i]);
+    //     }
+    // }
 }
 
 GoblinProof Goblin::prove(const MergeSettings merge_settings)
 {
     PROFILE_THIS_NAME("Goblin::prove");
 
     prove_merge(transcript, merge_settings); // Use shared transcript for merge proving
-    info("Constructing a Goblin proof with num ultra ops = ", op_queue->get_ultra_ops_table_num_rows());
+    info("Constructing a Goblin proof with num ultra ops = ", op_queue->get_ultra_ops().size());
 
     BB_ASSERT_EQ(merge_verification_queue.size(),
                  1U,

barretenberg/cpp/src/barretenberg/op_queue/ecc_op_queue.hpp

@@ -48,6 +48,7 @@ class ECCOpQueue {
     EccvmRowTracker eccvm_row_tracker;
 
   public:
+    static const size_t OP_QUEUE_SIZE = 1 << 13;
     /**
      * @brief Instantiate an initial ECC op subtable.
      */

barretenberg/cpp/src/barretenberg/op_queue/ecc_ops_table.hpp

@@ -74,6 +74,8 @@ struct UltraOp {
     Fr z_2;
     bool return_is_infinity;
 
+    bool operator==(const UltraOp& other) const = default;
+
     /**
      * @brief Get the point in standard form i.e. as two coordinates x and y in the base field or as a point at
      * infinity whose coordinates are set to (0,0).
@@ -237,7 +239,6 @@ class UltraEccOpsTable {
 
   public:
     size_t size() const { return table.size(); }
-    // size_t get_unmerged_subtable_size() const { return table.get_unmerged_subtable_size(); }
 
     size_t ultra_table_size() const
     {
@@ -249,7 +250,8 @@ class UltraEccOpsTable {
                 // The last subtable in deque is the fixed-location one
                 last_subtable_size = table.get().back().size() * NUM_ROWS_PER_OP;
             }
-            return std::max(base_size, fixed_append_offset.value() + last_subtable_size);
+            info("here");
+            return std::max(base_size, (fixed_append_offset.value() * NUM_ROWS_PER_OP) + last_subtable_size);
         }
         return base_size;
     }
@@ -275,14 +277,62 @@ class UltraEccOpsTable {
 
     size_t get_unmerged_subtable_size() const { return table.get_unmerged_subtable_size(); }
 
-    std::vector<UltraOp> get_reconstructed() const { return table.get_reconstructed(); }
+    std::vector<UltraOp> get_reconstructed() const
+    {
+        if (has_fixed_append) {
+            return get_reconstructed_with_fixed_append();
+        }
+        return table.get_reconstructed();
+    }
+    std::vector<UltraOp> get_reconstructed_with_fixed_append() const
+    {
+
+        ASSERT(get_unmerged_subtable_size() == 0,
+               "current subtable should be merged before reconstructing the full table of operations.");
+        info("Reconstructing with fixed append");
+
+        std::vector<UltraOp> reconstructed_table;
+        // reconstructed_table.reserve(reconstructed_table_size);
+
+        for (size_t subtable_idx = 0; subtable_idx < table.num_subtables() - 1; subtable_idx++) {
+            const auto& subtable = table.get()[subtable_idx];
+            for (const auto& op : subtable) {
+                reconstructed_table.push_back(op);
+            }
+        }
+        info("Size before shift: ", reconstructed_table.size());
+
+        // Add zeros if fixed offset is larger than current size
+        if (has_fixed_append && fixed_append_offset.has_value()) {
+            size_t current_size = reconstructed_table.size();
+            size_t target_offset = fixed_append_offset.value();
+
+            // Fill gap with no-ops if needed
+            while (current_size < target_offset) {
+                UltraOp no_op = {};
+                // no_op.op_code is already initialized with all false values (no operation)
+                reconstructed_table.push_back(no_op);
+                current_size++;
+            }
+        }
+
+        // Add the final subtable (appended at fixed location)
+        info("Size before appending final subtable: ", reconstructed_table.size());
+        const auto& final_subtable = table.get()[table.num_subtables() - 1];
+        for (const auto& op : final_subtable) {
+            reconstructed_table.push_back(op);
+        }
+        info("Reconstructed table size: ", reconstructed_table.size());
+        return reconstructed_table;
+    }
 
     // Construct the columns of the full ultra ecc ops table
     ColumnPolynomials construct_table_columns() const
     {
         const size_t poly_size = ultra_table_size();
 
         if (has_fixed_append) {
+            info("we should construct with fixed append ", poly_size);
             // Handle fixed-location append: prepended tables first, then appended table at fixed offset
             return construct_column_polynomials_with_fixed_append(poly_size);
         }
@@ -347,7 +397,7 @@ class UltraEccOpsTable {
 
         // Process all prepended subtables (all except last)
         size_t i = 0;
-        for (size_t subtable_idx = 0; subtable_idx < table.num_subtables() - 1; ++subtable_idx) {
+        for (size_t subtable_idx = 0; subtable_idx < table.num_subtables() - 1; subtable_idx++) {
             const auto& subtable = table.get()[subtable_idx];
             for (const auto& op : subtable) {
                 write_op_to_polynomials(column_polynomials, op, i);
@@ -356,7 +406,8 @@ class UltraEccOpsTable {
         }
 
         // Place the appended subtable at the fixed offset
-        size_t append_position = fixed_append_offset.value_or(i);
+        size_t append_position = fixed_append_offset.value_or(i) * NUM_ROWS_PER_OP;
+        info("append position: ", append_position);
         const auto& appended_subtable = table.get()[table.num_subtables() - 1];
 
         size_t j = append_position;

barretenberg/cpp/src/barretenberg/op_queue/ecc_ops_table.test.cpp

@@ -329,6 +329,39 @@ TEST(EccOpsTableTest, UltraOpsFixedLocationAppendWithGap)
             EXPECT_EQ(ultra_op_poly.at(fixed_offset + row), expected_poly[row]);
         }
     }
+
+    // Mimic get_reconstructed by unifying all the ops from subtables into a single vector with the appropiate gap of
+    // no-ops
+    {
+        // Compute how many no-op operations are needed to span the gap (fixed_offset and prepended_size are in rows)
+
+        std::vector<UltraOp> expected_reconstructed;
+        expected_reconstructed.reserve(expected_num_ops + fixed_offset);
+
+        // Order: subtable[1], subtable[0], gap (no-ops), subtable[2]
+        for (const auto& op : subtables[1]) {
+            expected_reconstructed.push_back(op);
+        }
+        for (const auto& op : subtables[0]) {
+            expected_reconstructed.push_back(op);
+        }
+
+        // Construct a canonical "no-op" UltraOp (fields zeroed)
+        UltraOp no_op = {};
+        size_t size_before = expected_reconstructed.size();
+        for (size_t i = size_before; i < fixed_offset; i++) {
+            expected_reconstructed.push_back(no_op);
+        }
+
+        for (const auto& op : subtables[2]) {
+            expected_reconstructed.push_back(op);
+        }
+
+        EXPECT_EQ(expected_reconstructed.size(), ultra_ops_table.get_reconstructed().size());
+
+        // Compare to the op-queue's reconstruction (should include the gap as no-ops)
+        EXPECT_EQ(expected_reconstructed, ultra_ops_table.get_reconstructed());
+    }
 }
 
 // Ensure EccvmOpsTable correctly constructs a concatenated table from successively prepended subtables

barretenberg/cpp/src/barretenberg/translator_vm/translator_circuit_builder.cpp

@@ -540,7 +540,7 @@ void TranslatorCircuitBuilder::feed_ecc_op_queue_into_circuit(const std::shared_
 
         const auto& ultra_op = ultra_ops[ultra_ops.size() - i];
         if (ultra_op.op_code.value() == 0) {
-            //  Skip  no-ops as
+            //  Skip no-ops as they should not affect the computation of the accumulator (or)
             continue;
         }
         current_accumulator *= evaluation_input_x;

barretenberg/cpp/src/barretenberg/translator_vm/translator_proving_key.hpp

@@ -49,7 +49,7 @@ class TranslatorProvingKey {
         PROFILE_THIS_NAME("TranslatorProvingKey(TranslatorCircuit&)");
         // Check that the Translator Circuit does not exceed the fixed upper bound, the current value amounts to
         // a number of EccOps sufficient for 10 rounds of folding (so 20 circuits)
-        if (circuit.num_gates > Flavor::MINI_CIRCUIT_SIZE - NUM_DISABLED_ROWS_IN_SUMCHECK) {
+        if (circuit.num_gates > Flavor::MINI_CIRCUIT_SIZE) {
             throw_or_abort("The Translator circuit size has exceeded the fixed upper bound");
         }
 

barretenberg/cpp/src/barretenberg/translator_vm/translator_verifier.cpp

@@ -204,6 +204,7 @@ bool TranslatorVerifier::verify_translation(const TranslationEvaluations& transl
  */
 bool TranslatorVerifier::verify_consistency_with_final_merge(const std::array<Commitment, 4>& merge_commitments)
 {
+
     if (op_queue_commitments[0] != merge_commitments[0]) {
         info("Consistency check failed: op commitment mismatch");
         return false;

barretenberg/cpp/src/barretenberg/ultra_honk/merge_prover.cpp

@@ -25,7 +25,15 @@ MergeProver::MergeProver(const std::shared_ptr<ECCOpQueue>& op_queue,
 {
     // Merge the current subtable (for which a merge proof is being constructed) prior to
     // procedeing with proving.
-    op_queue->merge(settings);
+    if (settings == MergeSettings::APPEND) {
+
+        op_queue->merge(settings, ECCOpQueue::OP_QUEUE_SIZE - 293);
+        info("hiding kernel subtable size? ", op_queue->get_current_ultra_ops_subtable_num_rows() / 2);
+
+    } else {
+        op_queue->merge(settings);
+    }
+
     pcs_commitment_key =
         commitment_key.initialized() ? commitment_key : CommitmentKey(op_queue->get_ultra_ops_table_num_rows());
 };