composer_lib.test.cpp

Go to the documentation of this file.

#include "barretenberg/honk/composer/composer_lib.hpp"
#include "barretenberg/flavor/ultra_flavor.hpp"
#include "barretenberg/honk/composer/permutation_lib.hpp"
#include "barretenberg/srs/factories/crs_factory.hpp"
#include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
#include "barretenberg/ultra_honk/ultra_honk.test.hpp"
 
#include <array>
#include <gtest/gtest.h>
 
using namespace bb;
 
class ComposerLibTests : public UltraHonkTests<UltraFlavor> {
  public:
    using Flavor = UltraFlavor;
    using FF = Flavor::FF;
    using Builder = UltraCircuitBuilder;
    using Polynomial = Flavor::Polynomial;
};
TEST_F(ComposerLibTests, LookupReadCounts)
{
    auto UINT32_XOR = plookup::MultiTableId::UINT32_XOR;
    Builder builder;
 
    // define some very simply inputs to XOR
    FF left{ 1 };
    FF right{ 5 };
 
    auto left_idx = builder.add_variable(left);
    auto right_idx = builder.add_variable(right);
 
    // create a single lookup from the uint32 XOR table
    auto accumulators = plookup::get_lookup_accumulators(UINT32_XOR, left, right, /*is_2_to_1_lookup*/ true);
    builder.create_gates_from_plookup_accumulators(UINT32_XOR, accumulators, left_idx, right_idx);
 
    EXPECT_EQ(builder.get_num_lookup_tables(), 2); // we only used two tables, first for 6 bits, second for 2 bits
    EXPECT_EQ(builder.get_lookup_tables()[0].size(), 4096); // first table has size 64*64 (6 bit operands)
    EXPECT_EQ(builder.get_lookup_tables()[1].size(), 16);   // first table has size 4*4 (2 bit operands)
 
    size_t circuit_size = 8192;
 
    Polynomial read_counts{ circuit_size };
    Polynomial read_tags{ circuit_size };
 
    builder.blocks.compute_offsets();
    construct_lookup_read_counts<Flavor>(read_counts, read_tags, builder);
 
    // The uint32 XOR lookup table is constructed for 6 bit operands via double for loop that iterates through the left
    // operand externally (0 to 63) then the right operand internally (0 to 63). Computing (1 XOR 5) will thus result in
    // 1 lookup from the (1*64 + 5)th index in the table and 4 lookups from the (0*64 + 0)th index (for the remaining 4
    // 6-bits limbs  that are all 0) and one lookup from second table from the (64 * 64 + 0) index (for last 2 bits).
    // The counts and tags at all other indices should be zero.
    for (auto [idx, count, tag] : zip_polys(read_counts, read_tags)) {
        if (idx == (0)) {
            EXPECT_EQ(count, 4);
            EXPECT_EQ(tag, 1);
        } else if (idx == (69)) {
            EXPECT_EQ(count, 1);
            EXPECT_EQ(tag, 1);
        } else if (idx == (64 * 64)) {
            EXPECT_EQ(count, 1);
            EXPECT_EQ(tag, 1);
        } else {
            EXPECT_EQ(count, 0);
            EXPECT_EQ(tag, 0);
        }
        idx++;
    }
}
 
TEST_F(ComposerLibTests, TagCollisionFailure)
{
    {
        Builder builder;
 
        FF val_a = FF::random_element();
        FF val_b = FF::random_element(); // Different value
        ASSERT_FALSE(val_a == val_b);
 
        auto a_idx = builder.add_variable(val_a);
        auto b_idx = builder.add_variable(val_b);
 
        auto first_tag = builder.get_new_tag();
        auto second_tag = builder.get_new_tag();
        builder.set_tau_transposition(first_tag, second_tag);
        // Assign the same tag to both variables (which have different values)
        // As we only have two witnesses, this forces a multiset-equality check `{val_a} == {val_b}`, which should fail.
        builder.assign_tag(a_idx, first_tag);
        builder.assign_tag(b_idx, second_tag);
 
        // Use the variables in gates so they appear in the trace
        builder.create_add_gate(
            { a_idx, builder.zero_idx(), builder.zero_idx(), FF::one(), FF::zero(), FF::zero(), -val_a });
        builder.create_add_gate(
            { b_idx, builder.zero_idx(), builder.zero_idx(), FF::one(), FF::zero(), FF::zero(), -val_b });
 
        // Add required pairing points for Ultra circuits
        set_default_pairing_points_and_ipa_claim_and_proof(builder);
        // prove and verify
        prove_and_verify(builder, /*expected_result=*/false);
    }
}