cleanup, fix tests, docs

Author: maramihali

barretenberg/cpp/scripts/test_civc_standalone_vks_havent_changed.sh

@@ -11,7 +11,7 @@ cd ..
 # - Generate a hash for versioning: sha256sum bb-civc-inputs.tar.gz
 # - Upload the compressed results: aws s3 cp bb-civc-inputs.tar.gz s3://aztec-ci-artifacts/protocol/bb-civc-inputs-[hash(0:8)].tar.gz
 # Note: In case of the "Test suite failed to run ... Unexpected token 'with' " error, need to run: docker pull aztecprotocol/build:3.0
-pinned_short_hash="869efec4"
+pinned_short_hash="9b31056f"
 pinned_civc_inputs_url="https://aztec-ci-artifacts.s3.us-east-2.amazonaws.com/protocol/bb-civc-inputs-${pinned_short_hash}.tar.gz"
 
 function compress_and_upload {

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

@@ -269,10 +269,9 @@ 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)
+        // Placeholder for randomness at the end of the hiding circuit
         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 };
@@ -316,6 +315,7 @@ 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();
+        // Placeholder for randomness at the beginning of tail circuit
         circuit.queue_ecc_no_op();
         circuit.queue_ecc_no_op();
     }

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

@@ -88,6 +88,7 @@ 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/constants.hpp

@@ -8,6 +8,11 @@ namespace bb {
 // permutation argument polynomials (sigmas, ids) are unique, e.g. id[i][j] == id[m][n] iff (i == m && j == n)
 constexpr uint32_t PERMUTATION_ARGUMENT_VALUE_SEPARATOR = 1 << 28;
 
+static constexpr uint32_t CONST_TRANSLATOR_MINI_CIRCUIT_LOG_SIZE = 14;
+
+// -1 as each op occupies two rows in Translator trace
+static constexpr uint32_t CONST_OP_QUEUE_LOG_SIZE = CONST_TRANSLATOR_MINI_CIRCUIT_LOG_SIZE - 1;
+
 // The log of the max circuit size assumed in order to achieve constant sized Honk proofs
 // TODO(https://github.com/AztecProtocol/barretenberg/issues/1046): Remove the need for const sized proofs
 static constexpr uint32_t CONST_PROOF_SIZE_LOG_N = 28;

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

@@ -45,31 +45,14 @@ 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().size());
+    info("Constructing a Goblin proof with num ultra ops = ", op_queue->get_ultra_ops_table_num_rows());
 
     BB_ASSERT_EQ(merge_verification_queue.size(),
                  1U,

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

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

barretenberg/cpp/src/barretenberg/op_queue/ecc_op_queue.test.cpp

@@ -54,7 +54,9 @@ class ECCOpQueueTest {
             } else {
                 // APPEND merge performs concatenation directly to end of previous table or at a specified fixed offset
                 const size_t prev_table_size = op_queue->get_previous_ultra_ops_table_num_rows(); // k
-                const size_t shift_magnitude = ultra_fixed_offset.value_or(prev_table_size);
+                const size_t shift_magnitude = ultra_fixed_offset.has_value()
+                                                   ? ultra_fixed_offset.value() * bb::UltraEccOpsTable::NUM_ROWS_PER_OP
+                                                   : prev_table_size; // k
                 // T(x) = T_prev(x) + x^k * t_current(x), where k is the shift magnitude
                 const Fr prev_table_eval = prev_table_poly.evaluate(eval_challenge); // T_prev(x)
                 const Fr shifted_subtable_eval =
@@ -74,10 +76,12 @@ class ECCOpQueueTest {
         auto ultra_table = op_queue->get_ultra_ops();
         auto eccvm_table = op_queue->get_eccvm_ops();
 
-        EXPECT_EQ(eccvm_table.size(), ultra_table.size());
-
-        for (auto [ultra_op, eccvm_op] : zip_view(ultra_table, eccvm_table)) {
-            EXPECT_EQ(ultra_op.op_code.value(), eccvm_op.op_code.value());
+        size_t j = 0;
+        for (const auto& ultra_op : ultra_table) {
+            if (ultra_op.op_code.value() == 0) {
+                continue;
+            }
+            EXPECT_EQ(ultra_op.op_code.value(), eccvm_table[j++].op_code.value());
         }
     };
 };

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

@@ -239,7 +239,6 @@ class UltraEccOpsTable {
 
   public:
     size_t size() const { return table.size(); }
-
     size_t ultra_table_size() const
     {
         size_t base_size = table.size() * NUM_ROWS_PER_OP;
@@ -250,7 +249,6 @@ class UltraEccOpsTable {
                 // The last subtable in deque is the fixed-location one
                 last_subtable_size = table.get().back().size() * NUM_ROWS_PER_OP;
             }
-            info("here");
             return std::max(base_size, (fixed_append_offset.value() * NUM_ROWS_PER_OP) + last_subtable_size);
         }
         return base_size;
@@ -279,7 +277,7 @@ class UltraEccOpsTable {
 
     std::vector<UltraOp> get_reconstructed() const
     {
-        if (has_fixed_append) {
+        if (has_fixed_append && fixed_append_offset.has_value()) {
             return get_reconstructed_with_fixed_append();
         }
         return table.get_reconstructed();
@@ -289,7 +287,6 @@ class UltraEccOpsTable {
 
         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);
@@ -300,7 +297,6 @@ class UltraEccOpsTable {
                 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()) {
@@ -317,12 +313,10 @@ class UltraEccOpsTable {
         }
 
         // 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;
     }
 
@@ -332,7 +326,6 @@ class UltraEccOpsTable {
         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);
         }
@@ -406,8 +399,7 @@ class UltraEccOpsTable {
         }
 
         // Place the appended subtable at the fixed offset
-        size_t append_position = fixed_append_offset.value_or(i) * NUM_ROWS_PER_OP;
-        info("append position: ", append_position);
+        size_t append_position = fixed_append_offset.has_value() ? fixed_append_offset.value() * NUM_ROWS_PER_OP : i;
         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

@@ -267,8 +267,9 @@ TEST(EccOpsTableTest, UltraOpsFixedLocationAppendWithGap)
 
     // Define a fixed offset at which to append the table (must be greater than the total size of the prepended tables)
     const size_t fixed_offset = 20;
+    const size_t fixed_offset_num_rows = fixed_offset * ULTRA_ROWS_PER_OP;
     const size_t prepended_size = (subtable_op_counts[0] + subtable_op_counts[1]) * ULTRA_ROWS_PER_OP;
-    ASSERT(fixed_offset > prepended_size);
+    ASSERT(fixed_offset_num_rows > prepended_size);
 
     // Construct the ultra ops table
     for (size_t i = 0; i < NUM_SUBTABLES; ++i) {
@@ -290,7 +291,7 @@ TEST(EccOpsTableTest, UltraOpsFixedLocationAppendWithGap)
     EXPECT_EQ(ultra_ops_table.size(), expected_num_ops);
 
     // Check that the polynomials have the correct size (including gap)
-    size_t expected_poly_size = fixed_offset + (subtable_op_counts[2] * ULTRA_ROWS_PER_OP);
+    size_t expected_poly_size = fixed_offset_num_rows + (subtable_op_counts[2] * ULTRA_ROWS_PER_OP);
     EXPECT_EQ(ultra_ops_table.ultra_table_size(), expected_poly_size);
 
     // Construct polynomials corresponding to the columns of the ultra ops table
@@ -316,7 +317,7 @@ TEST(EccOpsTableTest, UltraOpsFixedLocationAppendWithGap)
 
     // Check gap from offset to appended subtable is filled with zeros
     for (auto ultra_op_poly : ultra_ops_table_polynomials) {
-        for (size_t row = prepended_size; row < fixed_offset; ++row) {
+        for (size_t row = prepended_size; row < fixed_offset_num_rows; ++row) {
             EXPECT_EQ(ultra_op_poly.at(row), Fr::zero());
         }
     }
@@ -325,28 +326,26 @@ TEST(EccOpsTableTest, UltraOpsFixedLocationAppendWithGap)
     std::vector<std::vector<UltraOp>> appended_subtables = { subtables[2] };
     EccOpsTableTest::MockUltraOpsTable expected_appended_table(appended_subtables);
     for (auto [ultra_op_poly, expected_poly] : zip_view(ultra_ops_table_polynomials, expected_appended_table.columns)) {
-        for (size_t row = 0; row < subtable_op_counts[2] * ULTRA_ROWS_PER_OP; ++row) {
-            EXPECT_EQ(ultra_op_poly.at(fixed_offset + row), expected_poly[row]);
+        for (size_t row = 0; row < subtable_op_counts[2] * ULTRA_ROWS_PER_OP; row++) {
+            EXPECT_EQ(ultra_op_poly.at(fixed_offset_num_rows + 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
+    // Mimic get_reconstructed by unifying all the ops from subtables into a single vector with the appropiate append
+    // offset
     {
-        // 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]
+        // Order: subtable[1], subtable[0], no-ops range, 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)
+        // Add the range of noops
         UltraOp no_op = {};
         size_t size_before = expected_reconstructed.size();
         for (size_t i = size_before; i < fixed_offset; i++) {

barretenberg/cpp/src/barretenberg/relations/translator_vm/translator_decomposition_relation.hpp

@@ -16,12 +16,12 @@ template <typename FF_> class TranslatorDecompositionRelationImpl {
 
     // 1 + polynomial degree of this relation
     static constexpr size_t RELATION_LENGTH =
-        3; // degree(lagrange_even_in_minicircuit_in_minicircuit(a - a_0 - a_1*2¹⁴ ... - a_l⋅2¹⁴ˡ )) = 2
+        4; // degree(lagrange_even_in_minicircuit_in_minicircuit(a - a_0 - a_1*2¹⁴ ... - a_l⋅2¹⁴ˡ )op) = 3
     static constexpr std::array<size_t, 48> SUBRELATION_PARTIAL_LENGTHS{
-        4, // decomposition of P.x limb 0 into microlimbs subrelation
-        4, // decomposition of P.x limb 1 into microlimbs subrelation
-        4, // decomposition of P.x limb 2 into microlimbs subrelation
-        4, // decomposition of P.x limb 3 into microlimbs subrelation
+        4, // decomposition of accumulator limb 0 into microlimbs subrelation
+        4, // decomposition of accumulator limb 1 into microlimbs subrelation
+        4, // decomposition of accumulator limb 2 into microlimbs subrelation
+        4, // decomposition of accumulator limb 3 into microlimbs subrelation
         3, // decomposition of P.y limb 0 into microlimbs subrelation
         3, // decomposition of P.y limb 1 into microlimbs subrelation
         3, // decomposition of P.y limb 2 into microlimbs subrelation
@@ -30,10 +30,10 @@ template <typename FF_> class TranslatorDecompositionRelationImpl {
         3, // decomposition of z2 limb 0 into microlimbs subrelation
         3, // decomposition of z1 limb 1 into microlimbs subrelation
         3, // decomposition of z2 limb 1 into microlimbs subrelation
-        3, // decomposition of accumulator limb 0 into microlimbs subrelation
-        3, // decomposition of accumulator limb 1 into microlimbs subrelation
-        3, // decomposition of accumulator limb 2 into microlimbs subrelation
-        3, // decomposition of accumulator limb 3 into microlimbs subrelation
+        3, // decomposition of P.x limb 0 into microlimbs subrelation
+        3, // decomposition of P.x limb 1 into microlimbs subrelation
+        3, // decomposition of P.x limb 2 into microlimbs subrelation
+        3, // decomposition of P.x limb 3 into microlimbs subrelation
         3, // decomposition of quotient limb 0 into microlimbs subrelation
         3, // decomposition of quotient limb 1 into microlimbs subrelation
         3, // decomposition of quotient limb 2 into microlimbs subrelation