Raise origin tags to uint256

Author: federicobarbacovi

barretenberg/cpp/src/barretenberg/transcript/origin_tag.cpp

@@ -16,31 +16,36 @@ using namespace numeric;
 
 namespace {
 /**
- * @brief Find the position of the highest set bit in a uint128_t
- * @return -1 if no bits are set, otherwise the bit position (0-127)
+ * @brief Find the position of the highest set bit in a uint256_t
+ * @return -1 if no bits are set, otherwise the bit position (0-255)
  */
-inline int highest_set_bit_128(uint128_t value)
+inline int highest_set_bit_256(uint256_t value)
 {
     if (value == 0) {
         return -1;
     }
-    // Check high 64 bits first
-    auto high = static_cast<uint64_t>(value >> 64);
-    if (high != 0) {
-        return 127 - __builtin_clzll(high);
+    // Check high bits first, then go down
+    for (int idx = 0; idx < 3; idx++) {
+        auto chunk = static_cast<uint64_t>(value >> 64 * (3 - idx));
+        if (chunk != 0) {
+            return 255 - (idx * 64) - __builtin_clzll(chunk);
+        }
     }
-    // Check low 64 bits
-    auto low = static_cast<uint64_t>(value);
-    return 63 - __builtin_clzll(low);
+
+    // Lowest bits
+    auto chunk = static_cast<uint64_t>(value);
+    return 63 - __builtin_clzll(chunk);
 }
 
 /**
- * @brief Safely extract uint128_t from uint256_t data array using memcpy to avoid strict aliasing issues
+ * @brief Safely extract uint256_t from uint512_t data array using memcpy to avoid strict aliasing issues
  */
-inline uint128_t extract_uint128(const uint64_t* data)
+inline uint256_t extract_uint256(const uint256_t& data)
 {
-    uint128_t result = 0;
-    std::memcpy(&result, data, sizeof(uint128_t));
+    uint256_t result = 0;
+    for (size_t idx = 0; idx < 4; ++idx) {
+        std::memcpy(&result.data[idx], &data.data[idx], sizeof(uint64_t));
+    }
     return result;
 }
 } // namespace
@@ -60,22 +65,22 @@ inline uint128_t extract_uint128(const uint64_t* data)
  * @param provenance_a Round provenance of first element
  * @param provenance_b Round provenance of second element
  */
-void check_round_provenance(const uint256_t& provenance_a, const uint256_t& provenance_b)
+void check_round_provenance(const uint512_t& provenance_a, const uint512_t& provenance_b)
 {
-    // Lower 128 bits = submitted rounds, Upper 128 bits = challenge rounds
-    const auto submitted_a = extract_uint128(&provenance_a.data[0]);
-    const auto submitted_b = extract_uint128(&provenance_b.data[0]);
+    // Lower 256 bits = submitted rounds, Upper 256 bits = challenge rounds
+    const auto submitted_a = extract_uint256(provenance_a.lo);
+    const auto submitted_b = extract_uint256(provenance_b.lo);
 
     // Nothing to check if either has no submitted data or both are from the same round(s)
     if (submitted_a == 0 || submitted_b == 0 || submitted_a == submitted_b) {
         return;
     }
 
     // Ensure that values from different rounds are not mixing without max challenge round >= max submitted round
-    const auto challenges_a = extract_uint128(&provenance_a.data[2]);
-    const auto challenges_b = extract_uint128(&provenance_b.data[2]);
-    const int max_challenge_round = highest_set_bit_128(challenges_a | challenges_b);
-    const int max_submitted_round = highest_set_bit_128(submitted_a | submitted_b);
+    const auto challenges_a = extract_uint256(provenance_a.hi);
+    const auto challenges_b = extract_uint256(provenance_b.hi);
+    const int max_challenge_round = highest_set_bit_256(challenges_a | challenges_b);
+    const int max_submitted_round = highest_set_bit_256(submitted_a | submitted_b);
 
     if (max_challenge_round < max_submitted_round) {
         throw_or_abort("Round provenance check failed: max challenge round (" + std::to_string(max_challenge_round) +
@@ -92,8 +97,7 @@ OriginTag::OriginTag(const OriginTag& tag_a, const OriginTag& tag_b)
 {
     // Elements with instant death should not be touched
     if (tag_a.instant_death || tag_b.instant_death) {
-        throw_or_abort("Touched an element that should not have been touched. tag_a id: " +
-                       std::to_string(tag_a.tag_id) + ", tag_b id: " + std::to_string(tag_b.tag_id));
+        throw_or_abort("Touched an element that should not have been touched");
     }
     // If one of the tags is a constant, just use the other tag
     if (tag_a.transcript_index == CONSTANT) {
@@ -108,9 +112,7 @@ OriginTag::OriginTag(const OriginTag& tag_a, const OriginTag& tag_b)
     // A free witness element should not interact with an element that has an origin
     if (tag_a.is_free_witness()) {
         if (!tag_b.is_free_witness() && !tag_b.is_empty()) {
-            throw_or_abort(
-                "A free witness element (id: " + std::to_string(tag_a.tag_id) +
-                ") should not interact with an element that has an origin (id: " + std::to_string(tag_b.tag_id) + ")");
+            throw_or_abort("A free witness element should not interact with an element that has an origin");
         } else {
             // If both are free witnesses or one of them is empty, just use tag_a
             *this = tag_a;
@@ -119,9 +121,7 @@ OriginTag::OriginTag(const OriginTag& tag_a, const OriginTag& tag_b)
     }
     if (tag_b.is_free_witness()) {
         if (!tag_a.is_free_witness() && !tag_a.is_empty()) {
-            throw_or_abort(
-                "A free witness element (id: " + std::to_string(tag_b.tag_id) +
-                ") should not interact with an element that has an origin (id: " + std::to_string(tag_a.tag_id) + ")");
+            throw_or_abort("A free witness element should not interact with an element that has an origin");
         } else {
             // If both are free witnesses or one of them is empty, just use tag_b
             *this = tag_b;
@@ -130,10 +130,7 @@ OriginTag::OriginTag(const OriginTag& tag_a, const OriginTag& tag_b)
     }
     // Elements from different transcripts shouldn't interact
     if (tag_a.transcript_index != tag_b.transcript_index) {
-        throw_or_abort("Tags from different transcripts were involved in the same computation. tag_a: { id: " +
-                       std::to_string(tag_a.tag_id) + ", transcript: " + std::to_string(tag_a.transcript_index) +
-                       " } tag_b: { id: " + std::to_string(tag_b.tag_id) +
-                       ", transcript: " + std::to_string(tag_b.transcript_index) + " }");
+        throw_or_abort("Tags from different transcripts were involved in the same computation");
     }
     // Check that submitted values from different rounds don't mix without challenges
     check_round_provenance(tag_a.round_provenance, tag_b.round_provenance);

barretenberg/cpp/src/barretenberg/transcript/origin_tag.hpp

@@ -16,7 +16,7 @@
 #include "barretenberg/common/assert.hpp"
 #include "barretenberg/common/throw_or_abort.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
-#include <atomic>
+#include "barretenberg/numeric/uintx/uintx.hpp"
 #include <cstddef>
 #include <iterator>
 #include <ostream>
@@ -65,15 +65,10 @@ template <typename T> constexpr bool is_iterable_v = is_iterable<T>::value;
 
 namespace bb {
 
-void check_round_provenance(const uint256_t& provenance_a, const uint256_t& provenance_b);
+void check_round_provenance(const uint512_t& provenance_a, const uint512_t& provenance_b);
 #ifndef AZTEC_NO_ORIGIN_TAGS
 struct OriginTag {
 
-    // Unique per-object ID for debugging: when a tag merge fails, the error message includes
-    // the IDs of both tags so you can trace which specific field elements were involved.
-    static inline std::atomic<uint64_t> next_tag_id{ 0 };
-    uint64_t tag_id = next_tag_id.fetch_add(1, std::memory_order_relaxed);
-
     static constexpr size_t CONSTANT = static_cast<size_t>(-1);
     static constexpr size_t FREE_WITNESS = static_cast<size_t>(-2);
     // transcript_index represents the index of a unique transcript object that generated the value. It uses
@@ -87,10 +82,10 @@ struct OriginTag {
     size_t transcript_index = FREE_WITNESS;
 
     // round_provenance specifies which submitted values and challenges have been used to generate this element
-    // The lower 128 bits represent using a submitted value from a corresponding round (the shift represents the
-    // round) The higher 128 bits represent using a challenge value from an corresponding round (the shift
+    // The lower 256 bits represent using a submitted value from a corresponding round (the shift represents the
+    // round) The higher 256 bits represent using a challenge value from an corresponding round (the shift
     // represents the round)
-    numeric::uint256_t round_provenance = numeric::uint256_t(0);
+    numeric::uint512_t round_provenance = numeric::uint512_t(0);
 
     // Instant death is used for poisoning values we should never use in arithmetic
     bool instant_death = false;
@@ -102,7 +97,7 @@ struct OriginTag {
     OriginTag& operator=(const OriginTag& other) = default;
     OriginTag& operator=(OriginTag&& other) noexcept
     {
-        tag_id = other.tag_id;
+
         transcript_index = other.transcript_index;
         round_provenance = other.round_provenance;
         instant_death = other.instant_death;
@@ -117,9 +112,9 @@ struct OriginTag {
      */
     OriginTag(size_t transcript_idx, size_t round_number, bool is_submitted = true)
         : transcript_index(transcript_idx)
-        , round_provenance((static_cast<uint256_t>(1) << (round_number + (is_submitted ? 0 : 128))))
+        , round_provenance((static_cast<uint512_t>(1) << (round_number + (is_submitted ? 0 : 256))))
     {
-        // BB_ASSERT_LT(round_number, 128U);
+        BB_ASSERT_LT(round_number, 256U);
     }
 
     /**
@@ -171,14 +166,14 @@ struct OriginTag {
     void unset_free_witness()
     {
         transcript_index = CONSTANT;
-        round_provenance = numeric::uint256_t(0);
+        round_provenance = numeric::uint512_t(0);
     }
 
     bool is_constant() const { return transcript_index == CONSTANT && !instant_death; }
     void set_constant()
     {
         transcript_index = CONSTANT;
-        round_provenance = numeric::uint256_t(0);
+        round_provenance = numeric::uint512_t(0);
     }
 
     // Static factory methods for cleaner syntax
@@ -206,12 +201,12 @@ struct OriginTag {
     /**
      * @brief Clear the round_provenance to address round provenance false positives.
      */
-    void clear_round_provenance() { round_provenance = numeric::uint256_t(0); }
+    void clear_round_provenance() { round_provenance = numeric::uint512_t(0); }
 };
 inline std::ostream& operator<<(std::ostream& os, OriginTag const& v)
 {
-    return os << "{ id: " << v.tag_id << ", transcript_idx: " << v.transcript_index
-              << ", round_prov: " << v.round_provenance << ", instadeath: " << v.instant_death << " }";
+    return os << "{ transcript_idx: " << v.transcript_index << ", round_prov: " << v.round_provenance
+              << ", instadeath: " << v.instant_death << " }";
 }
 
 #else