Barretenberg: src/barretenberg/relations/databus_lookup_relation_consistency.test.cpp Source File

#include "barretenberg/ecc/curves/bn254/fr.hpp"

#include "barretenberg/relations/databus_lookup_relation.hpp"

#include "barretenberg/relations/relation_parameters.hpp"

#include <gtest/gtest.h>


using namespace bb;


using FF = fr;


struct DatabusInputElements {

    // Wires used in read gates

    FF w_l;        // value being read

    FF w_r;        // index into bus column

    FF databus_id; // id/index in the bus (for write term)


    // Read gate selector

    FF q_busread;


    // Column selectors (determine which bus column is being read)

    FF q_l; // kernel calldata selector

    FF q_r; // first app calldata selector

    FF q_o; // second app calldata selector

    FF q_4; // third app calldata selector

    FF q_m; // return data selector


    // Kernel calldata (bus_idx = 0)

    FF kernel_calldata;

    FF kernel_calldata_read_counts;

    FF kernel_calldata_inverses;


    // First app calldata (bus_idx = 1)

    FF first_app_calldata;

    FF first_app_calldata_read_counts;

    FF first_app_calldata_inverses;


    // Second app calldata (bus_idx = 2)

    FF second_app_calldata;

    FF second_app_calldata_read_counts;

    FF second_app_calldata_inverses;


    // Third app calldata (bus_idx = 3)

    FF third_app_calldata;

    FF third_app_calldata_read_counts;

    FF third_app_calldata_inverses;


    // Return data (bus_idx = 4)

    FF return_data;

    FF return_data_read_counts;

    FF return_data_inverses;


    static DatabusInputElements get_random()

    {

        DatabusInputElements result;

        result.w_l = FF::random_element();

        result.w_r = FF::random_element();

        result.databus_id = FF::random_element();

        result.q_busread = FF::random_element();

        result.q_l = FF::random_element();

        result.q_r = FF::random_element();

        result.q_o = FF::random_element();

        result.q_4 = FF::random_element();

        result.q_m = FF::random_element();

        result.kernel_calldata = FF::random_element();

        result.kernel_calldata_read_counts = FF::random_element();

        result.kernel_calldata_inverses = FF::random_element();

        result.first_app_calldata = FF::random_element();

        result.first_app_calldata_read_counts = FF::random_element();

        result.first_app_calldata_inverses = FF::random_element();

        result.second_app_calldata = FF::random_element();

        result.second_app_calldata_read_counts = FF::random_element();

        result.second_app_calldata_inverses = FF::random_element();

        result.third_app_calldata = FF::random_element();

        result.third_app_calldata_read_counts = FF::random_element();

        result.third_app_calldata_inverses = FF::random_element();

        result.return_data = FF::random_element();

        result.return_data_read_counts = FF::random_element();

        result.return_data_inverses = FF::random_element();

        return result;

    }


    // Create inputs representing a valid read gate for kernel_calldata


    static DatabusInputElements get_valid_calldata_read()

    {

        DatabusInputElements result{};


        // Set up a read from kernel_calldata at index 5, value 42

        result.w_l = FF(42);             // value being read

        result.w_r = FF(5);              // index

        result.databus_id = FF(5);       // same index in the bus

        result.kernel_calldata = FF(42); // value in bus matches


        // Enable read gate for kernel_calldata

        result.q_busread = FF(1);

        result.q_l = FF(1); // kernel_calldata selector

        result.q_r = FF(0);

        result.q_o = FF(0);

        result.q_4 = FF(0);

        result.q_m = FF(0);


        // Read counts

        result.kernel_calldata_read_counts = FF(1);


        // Other columns inactive

        result.first_app_calldata_read_counts = FF(0);

        result.second_app_calldata_read_counts = FF(0);

        result.third_app_calldata_read_counts = FF(0);

        result.return_data_read_counts = FF(0);


        return result;

    }


};


class DatabusLookupRelationConsistency : public testing::Test {

  public:

    using Relation = DatabusLookupRelationImpl<FF>;

    static constexpr size_t NUM_SUBRELATIONS = Relation::SUBRELATION_PARTIAL_LENGTHS.size();


    static void validate_relation_execution(const std::array<FF, NUM_SUBRELATIONS>& expected_values,

                                            const DatabusInputElements& input_elements,

                                            const RelationParameters<FF>& parameters)

    {

        std::array<FF, NUM_SUBRELATIONS> accumulator{};

        Relation::accumulate(accumulator, input_elements, parameters, FF(1));

        EXPECT_EQ(accumulator, expected_values);

    }


};


static std::array<FF, DatabusLookupRelationConsistency::NUM_SUBRELATIONS> compute_expected_values(

    const DatabusInputElements& in, const RelationParameters<FF>& params)

{

    const auto& beta = params.beta;

    const auto& gamma = params.gamma;


    std::array<FF, DatabusLookupRelationConsistency::NUM_SUBRELATIONS> expected_values;

    std::fill(expected_values.begin(), expected_values.end(), FF(0));


    // Read term (same for all columns): value + index * beta + gamma

    auto lookup_term = in.w_l + in.w_r * beta + gamma;


    // Lambda to compute subrelations for a given bus column

    auto compute_column_subrelations =

        [&](size_t bus_idx, FF column_selector, FF bus_value, FF read_counts, FF inverses) {

            auto is_read = in.q_busread * column_selector;

            auto table_term = bus_value + in.databus_id * beta + gamma;


            // Common: I * L * T - 1

            auto common = lookup_term * table_term * inverses - FF(1);


            // Subrelation 1a: Inverse correctness on read rows: (I*L*T - 1) * is_read

            expected_values[bus_idx * 3] = common * is_read;


            // Subrelation 1b: Inverse correctness on write rows: (I*L*T - 1) * count

            expected_values[bus_idx * 3 + 1] = common * read_counts;


            // Subrelation 2: Log-derivative lookup (no scaling factor since linearly dependent)

            expected_values[bus_idx * 3 + 2] = (is_read * table_term - read_counts * lookup_term) * inverses;

        };


    // Bus column 0 (kernel_calldata)

    compute_column_subrelations(

        0, in.q_l, in.kernel_calldata, in.kernel_calldata_read_counts, in.kernel_calldata_inverses);


    // Bus column 1 (first_app_calldata)

    compute_column_subrelations(

        1, in.q_r, in.first_app_calldata, in.first_app_calldata_read_counts, in.first_app_calldata_inverses);


    // Bus column 2 (second_app_calldata)

    compute_column_subrelations(

        2, in.q_o, in.second_app_calldata, in.second_app_calldata_read_counts, in.second_app_calldata_inverses);


    // Bus column 3 (third_app_calldata)

    compute_column_subrelations(

        3, in.q_4, in.third_app_calldata, in.third_app_calldata_read_counts, in.third_app_calldata_inverses);


    // Bus column 4 (return_data)

    compute_column_subrelations(4, in.q_m, in.return_data, in.return_data_read_counts, in.return_data_inverses);


    return expected_values;

}


TEST_F(DatabusLookupRelationConsistency, RandomInputs)

{

    const auto run_test = [](bool random_inputs) {

        DatabusInputElements in =

            random_inputs ? DatabusInputElements::get_random() : DatabusInputElements::get_valid_calldata_read();


        const auto parameters = RelationParameters<FF>::get_random();

        auto expected_values = compute_expected_values(in, parameters);


        validate_relation_execution(expected_values, in, parameters);

    };


    run_test(/*random_inputs=*/false);

    run_test(/*random_inputs=*/true);

}


TEST_F(DatabusLookupRelationConsistency, InactiveGates)

{

    const auto parameters = RelationParameters<FF>::get_random();


    DatabusInputElements in{};

    in.q_busread = FF(0);

    in.q_l = FF(0);

    in.q_r = FF(0);

    in.q_o = FF(0);

    in.q_4 = FF(0);

    in.q_m = FF(0);

    in.kernel_calldata_read_counts = FF(0);

    in.first_app_calldata_read_counts = FF(0);

    in.second_app_calldata_read_counts = FF(0);

    in.third_app_calldata_read_counts = FF(0);

    in.return_data_read_counts = FF(0);


    // Set other values non-zero to ensure they don't affect inactive gates

    in.w_l = FF(42);

    in.w_r = FF(5);

    in.databus_id = FF(5);

    in.kernel_calldata = FF(42);

    in.kernel_calldata_inverses = FF(0); // inverse should be 0 when inactive

    in.first_app_calldata = FF(100);

    in.first_app_calldata_inverses = FF(0);

    in.second_app_calldata = FF(200);

    in.second_app_calldata_inverses = FF(0);

    in.third_app_calldata = FF(300);

    in.third_app_calldata_inverses = FF(0);

    in.return_data = FF(400);

    in.return_data_inverses = FF(0);


    std::array<FF, NUM_SUBRELATIONS> accumulator{};

    Relation::accumulate(accumulator, in, parameters, FF(1));


    // All subrelations should be 0 when inactive

    for (size_t i = 0; i < NUM_SUBRELATIONS; i++) {

        EXPECT_EQ(accumulator[i], FF(0)) << "Subrelation " << i << " should be zero for inactive gates";

    }

}


TEST_F(DatabusLookupRelationConsistency, ValidInverseComputation)

{

    const auto parameters = RelationParameters<FF>::get_random();

    const auto& beta = parameters.beta;

    const auto& gamma = parameters.gamma;


    DatabusInputElements in{};


    // Set up a read gate for kernel_calldata

    in.q_busread = FF(1);

    in.q_l = FF(1); // kernel_calldata selector

    in.q_r = FF(0);

    in.q_o = FF(0);


    // Value and index

    FF value = FF(42);

    FF index = FF(5);

    in.w_l = value;             // value being read

    in.w_r = index;             // index

    in.databus_id = index;      // same index in the bus

    in.kernel_calldata = value; // value in bus matches


    // Compute the correct inverse

    auto lookup_term = value + index * beta + gamma;

    auto table_term = value + index * beta + gamma; // same since value and index match

    auto inverse = (lookup_term * table_term).invert();

    in.kernel_calldata_inverses = inverse;


    in.kernel_calldata_read_counts = FF(1);


    // Other columns inactive

    in.first_app_calldata_read_counts = FF(0);

    in.first_app_calldata_inverses = FF(0);

    in.second_app_calldata_read_counts = FF(0);

    in.second_app_calldata_inverses = FF(0);

    in.third_app_calldata_read_counts = FF(0);

    in.third_app_calldata_inverses = FF(0);

    in.return_data_read_counts = FF(0);

    in.return_data_inverses = FF(0);


    std::array<FF, NUM_SUBRELATIONS> accumulator{};

    Relation::accumulate(accumulator, in, parameters, FF(1));


    // (1a) Inverse correctness on read: (I*L*T - 1) * is_read = (1 - 1) * 1 = 0

    EXPECT_EQ(accumulator[0], FF(0));


    // (1b) Inverse correctness on write: (I*L*T - 1) * count = (1 - 1) * 1 = 0

    EXPECT_EQ(accumulator[1], FF(0));


    // (2) Lookup: (is_read*T - count*L) * I = (T - L) * I = 0 (since L == T here)

    EXPECT_EQ(accumulator[2], FF(0));


    // Other columns should have all-zero subrelations (inactive)

    for (size_t i = 3; i < NUM_SUBRELATIONS; i++) {

        EXPECT_EQ(accumulator[i], FF(0)) << "Inactive column subrelation " << i << " should be zero";

    }

}


TEST_F(DatabusLookupRelationConsistency, MismatchedReadWriteTerms)

{

    const auto parameters = RelationParameters<FF>::get_random();

    const auto& beta = parameters.beta;

    const auto& gamma = parameters.gamma;


    DatabusInputElements in{};


    // Set up a read gate for kernel_calldata

    in.q_busread = FF(1);

    in.q_l = FF(1);

    in.q_r = FF(0);

    in.q_o = FF(0);


    // Value being read differs from value in bus!

    FF read_value = FF(42);

    FF bus_value = FF(100); // Different!

    FF index = FF(5);


    in.w_l = read_value;

    in.w_r = index;

    in.databus_id = index;

    in.kernel_calldata = bus_value;


    auto lookup_term = read_value + index * beta + gamma;

    auto table_term = bus_value + index * beta + gamma;

    auto inverse = (lookup_term * table_term).invert();

    in.kernel_calldata_inverses = inverse;


    in.kernel_calldata_read_counts = FF(1);

    in.first_app_calldata_read_counts = FF(0);

    in.first_app_calldata_inverses = FF(0);

    in.second_app_calldata_read_counts = FF(0);

    in.second_app_calldata_inverses = FF(0);

    in.third_app_calldata_read_counts = FF(0);

    in.third_app_calldata_inverses = FF(0);

    in.return_data_read_counts = FF(0);

    in.return_data_inverses = FF(0);


    std::array<FF, NUM_SUBRELATIONS> accumulator{};

    Relation::accumulate(accumulator, in, parameters, FF(1));


    // (1a) Inverse correctness still satisfied (I is correct for these terms)

    EXPECT_EQ(accumulator[0], FF(0));


    // (1b) Inverse correctness on write: (I*L*T - 1) * count = 0 * 1 = 0 (I*L*T = 1)

    EXPECT_EQ(accumulator[1], FF(0));


    // (2) Lookup subrelation is non-zero because lookup_term != table_term

    // (is_read * table_term - count * lookup_term) * I = (table_term - lookup_term) * I

    FF expected_lookup = (table_term - lookup_term) * inverse;

    EXPECT_EQ(accumulator[2], expected_lookup);

    EXPECT_NE(accumulator[2], FF(0));

}


TEST_F(DatabusLookupRelationConsistency, InverseUnconstrainedAtInactiveRows)

{

    const auto parameters = RelationParameters<FF>::get_random();


    DatabusInputElements in{};

    in.q_busread = FF(0);

    in.q_l = FF(0);

    in.q_r = FF(0);

    in.q_o = FF(0);

    in.kernel_calldata_read_counts = FF(0);

    in.first_app_calldata_read_counts = FF(0);

    in.second_app_calldata_read_counts = FF(0);

    in.third_app_calldata_read_counts = FF(0);

    in.return_data_read_counts = FF(0);


    // Set inverses to arbitrary nonzero values — should not matter

    in.kernel_calldata_inverses = FF(999);

    in.first_app_calldata_inverses = FF(777);

    in.second_app_calldata_inverses = FF(555);

    in.third_app_calldata_inverses = FF(333);

    in.return_data_inverses = FF(111);


    in.w_l = FF(42);

    in.w_r = FF(5);

    in.databus_id = FF(5);

    in.kernel_calldata = FF(42);


    std::array<FF, NUM_SUBRELATIONS> accumulator{};

    Relation::accumulate(accumulator, in, parameters, FF(1));


    // (1a) gated by is_read = 0: always zero regardless of I

    EXPECT_EQ(accumulator[0], FF(0));

    EXPECT_EQ(accumulator[3], FF(0));

    EXPECT_EQ(accumulator[6], FF(0));


    // (1b) gated by count = 0: always zero regardless of I

    EXPECT_EQ(accumulator[1], FF(0));

    EXPECT_EQ(accumulator[4], FF(0));

    EXPECT_EQ(accumulator[7], FF(0));


    // (2) lookup: (0 * T - 0 * L) * I = 0 regardless of I

    EXPECT_EQ(accumulator[2], FF(0));

    EXPECT_EQ(accumulator[5], FF(0));

    EXPECT_EQ(accumulator[8], FF(0));

}


TEST_F(DatabusLookupRelationConsistency, WrongInverseOnReadRowFails)

{

    const auto parameters = RelationParameters<FF>::get_random();

    const auto& beta = parameters.beta;

    const auto& gamma = parameters.gamma;


    DatabusInputElements in{};

    in.q_busread = FF(1);

    in.q_l = FF(1);

    in.q_r = FF(0);

    in.q_o = FF(0);


    FF value = FF(42);

    FF index = FF(5);

    in.w_l = value;

    in.w_r = index;

    in.databus_id = index;

    in.kernel_calldata = value;


    // Set a WRONG inverse (just some arbitrary value, not 1/(L*T))

    in.kernel_calldata_inverses = FF(777);

    in.kernel_calldata_read_counts = FF(0); // pure read row, no write

    in.first_app_calldata_read_counts = FF(0);

    in.first_app_calldata_inverses = FF(0);

    in.second_app_calldata_read_counts = FF(0);

    in.second_app_calldata_inverses = FF(0);

    in.third_app_calldata_read_counts = FF(0);

    in.third_app_calldata_inverses = FF(0);

    in.return_data_read_counts = FF(0);

    in.return_data_inverses = FF(0);


    auto lookup_term = value + index * beta + gamma;

    auto table_term = value + index * beta + gamma;


    std::array<FF, NUM_SUBRELATIONS> accumulator{};

    Relation::accumulate(accumulator, in, parameters, FF(1));


    // (1a) should be nonzero: (I*L*T - 1) * is_read = (777*L*T - 1) * 1 != 0

    FF expected_1a = (FF(777) * lookup_term * table_term - FF(1)) * FF(1); // is_read = q_busread * q_l = 1

    EXPECT_EQ(accumulator[0], expected_1a);

    EXPECT_NE(accumulator[0], FF(0));


    // (1b) should be zero: gated by count = 0

    EXPECT_EQ(accumulator[1], FF(0));

}


TEST_F(DatabusLookupRelationConsistency, WrongInverseOnWriteRowFails)

{

    const auto parameters = RelationParameters<FF>::get_random();

    const auto& beta = parameters.beta;

    const auto& gamma = parameters.gamma;


    DatabusInputElements in{};

    // No read gate active

    in.q_busread = FF(0);

    in.q_l = FF(0);

    in.q_r = FF(0);

    in.q_o = FF(0);


    FF value = FF(42);

    FF index = FF(5);

    in.databus_id = index;

    in.kernel_calldata = value;

    in.w_l = FF(0); // irrelevant (no read gate)

    in.w_r = FF(0);


    // Row has nonzero read_count (it's been read from elsewhere) but wrong inverse

    in.kernel_calldata_read_counts = FF(3);

    in.kernel_calldata_inverses = FF(999); // WRONG


    in.first_app_calldata_read_counts = FF(0);

    in.first_app_calldata_inverses = FF(0);

    in.second_app_calldata_read_counts = FF(0);

    in.second_app_calldata_inverses = FF(0);

    in.third_app_calldata_read_counts = FF(0);

    in.third_app_calldata_inverses = FF(0);

    in.return_data_read_counts = FF(0);

    in.return_data_inverses = FF(0);


    auto lookup_term = in.w_l + in.w_r * beta + gamma; // = gamma (wires are 0)

    auto table_term = value + index * beta + gamma;


    std::array<FF, NUM_SUBRELATIONS> accumulator{};

    Relation::accumulate(accumulator, in, parameters, FF(1));


    // (1a) should be zero: gated by is_read = q_busread * q_l = 0

    EXPECT_EQ(accumulator[0], FF(0));


    // (1b) should be nonzero: (I*L*T - 1) * count = (999*L*T - 1) * 3 != 0

    FF expected_1b = (FF(999) * lookup_term * table_term - FF(1)) * FF(3);

    EXPECT_EQ(accumulator[1], expected_1b);

    EXPECT_NE(accumulator[1], FF(0));

}


TEST_F(DatabusLookupRelationConsistency, CorrectInverseOnWriteRow)

{

    const auto parameters = RelationParameters<FF>::get_random();

    const auto& beta = parameters.beta;

    const auto& gamma = parameters.gamma;


    DatabusInputElements in{};

    in.q_busread = FF(0);

    in.q_l = FF(0);

    in.q_r = FF(0);

    in.q_o = FF(0);


    FF value = FF(42);

    FF index = FF(5);

    in.databus_id = index;

    in.kernel_calldata = value;

    in.w_l = FF(0);

    in.w_r = FF(0);


    auto lookup_term = in.w_l + in.w_r * beta + gamma;

    auto table_term = value + index * beta + gamma;


    // Correct inverse

    in.kernel_calldata_inverses = (lookup_term * table_term).invert();

    in.kernel_calldata_read_counts = FF(3);


    in.first_app_calldata_read_counts = FF(0);

    in.first_app_calldata_inverses = FF(0);

    in.second_app_calldata_read_counts = FF(0);

    in.second_app_calldata_inverses = FF(0);

    in.third_app_calldata_read_counts = FF(0);

    in.third_app_calldata_inverses = FF(0);

    in.return_data_read_counts = FF(0);

    in.return_data_inverses = FF(0);


    std::array<FF, NUM_SUBRELATIONS> accumulator{};

    Relation::accumulate(accumulator, in, parameters, FF(1));


    // (1a) zero: is_read = 0

    EXPECT_EQ(accumulator[0], FF(0));


    // (1b) zero: (1 - 1) * 3 = 0

    EXPECT_EQ(accumulator[1], FF(0));


    // (2) lookup: (0*T - 3*L) * I = -3*L/(L*T) = -3/T

    FF expected_lookup = (FF(0) * table_term - FF(3) * lookup_term) * (lookup_term * table_term).invert();

    EXPECT_EQ(accumulator[2], expected_lookup);

    EXPECT_NE(accumulator[2], FF(0)); // nonzero contribution (balances across the full trace sum)

}


DatabusLookupRelationConsistency
Definition databus_lookup_relation_consistency.test.cpp:128

DatabusLookupRelationConsistency::validate_relation_execution
static void validate_relation_execution(const std::array< FF, NUM_SUBRELATIONS > &expected_values, const DatabusInputElements &input_elements, const RelationParameters< FF > &parameters)
Validate that the relation's accumulate function produces expected values.
Definition databus_lookup_relation_consistency.test.cpp:136

DatabusLookupRelationConsistency::NUM_SUBRELATIONS
static constexpr size_t NUM_SUBRELATIONS
Definition databus_lookup_relation_consistency.test.cpp:131

bb::DatabusLookupRelationImpl
Log-derivative lookup argument relation for establishing DataBus reads.
Definition databus_lookup_relation.hpp:61

bb::DatabusLookupRelationImpl::SUBRELATION_PARTIAL_LENGTHS
static constexpr std::array< size_t, NUM_SUB_RELATION_PER_IDX *NUM_BUS_COLUMNS > SUBRELATION_PARTIAL_LENGTHS
Definition databus_lookup_relation.hpp:95

bb::DatabusLookupRelationImpl::accumulate
static void accumulate(ContainerOverSubrelations &accumulator, const AllEntities &in, const Parameters &params, const FF &scaling_factor)
Accumulate the log derivative databus lookup argument subrelation contributions for each databus colu...
Definition databus_lookup_relation.hpp:328

VariableRefMutationOptions::index
@ index

value
FF value
Definition indexed_tree_check.test.cpp:69

databus_lookup_relation.hpp

FF
fr FF
Definition databus_lookup_relation_consistency.test.cpp:19

fr.hpp

bb
Entry point for Barretenberg command-line interface.
Definition api.hpp:5

bb::TEST_F
TEST_F(IPATest, ChallengesAreZero)
Definition ipa.test.cpp:155

bb::fr
field< Bn254FrParams > fr
Definition fr.hpp:155

std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13

relation_parameters.hpp

DatabusInputElements
Input elements for DatabusLookupRelation testing.
Definition databus_lookup_relation_consistency.test.cpp:25

DatabusInputElements::get_random
static DatabusInputElements get_random()
Definition databus_lookup_relation_consistency.test.cpp:66

DatabusInputElements::databus_id
FF databus_id
Definition databus_lookup_relation_consistency.test.cpp:29

DatabusInputElements::kernel_calldata_inverses
FF kernel_calldata_inverses
Definition databus_lookup_relation_consistency.test.cpp:44

DatabusInputElements::third_app_calldata_read_counts
FF third_app_calldata_read_counts
Definition databus_lookup_relation_consistency.test.cpp:58

DatabusInputElements::w_r
FF w_r
Definition databus_lookup_relation_consistency.test.cpp:28

DatabusInputElements::second_app_calldata_inverses
FF second_app_calldata_inverses
Definition databus_lookup_relation_consistency.test.cpp:54

DatabusInputElements::w_l
FF w_l
Definition databus_lookup_relation_consistency.test.cpp:27

DatabusInputElements::q_m
FF q_m
Definition databus_lookup_relation_consistency.test.cpp:39

DatabusInputElements::return_data_read_counts
FF return_data_read_counts
Definition databus_lookup_relation_consistency.test.cpp:63

DatabusInputElements::second_app_calldata_read_counts
FF second_app_calldata_read_counts
Definition databus_lookup_relation_consistency.test.cpp:53

DatabusInputElements::first_app_calldata_inverses
FF first_app_calldata_inverses
Definition databus_lookup_relation_consistency.test.cpp:49

DatabusInputElements::kernel_calldata_read_counts
FF kernel_calldata_read_counts
Definition databus_lookup_relation_consistency.test.cpp:43

DatabusInputElements::q_busread
FF q_busread
Definition databus_lookup_relation_consistency.test.cpp:32

DatabusInputElements::first_app_calldata_read_counts
FF first_app_calldata_read_counts
Definition databus_lookup_relation_consistency.test.cpp:48

DatabusInputElements::return_data_inverses
FF return_data_inverses
Definition databus_lookup_relation_consistency.test.cpp:64

DatabusInputElements::get_valid_calldata_read
static DatabusInputElements get_valid_calldata_read()
Definition databus_lookup_relation_consistency.test.cpp:97

DatabusInputElements::q_l
FF q_l
Definition databus_lookup_relation_consistency.test.cpp:35

DatabusInputElements::second_app_calldata
FF second_app_calldata
Definition databus_lookup_relation_consistency.test.cpp:52

DatabusInputElements::kernel_calldata
FF kernel_calldata
Definition databus_lookup_relation_consistency.test.cpp:42

DatabusInputElements::q_4
FF q_4
Definition databus_lookup_relation_consistency.test.cpp:38

DatabusInputElements::q_r
FF q_r
Definition databus_lookup_relation_consistency.test.cpp:36

DatabusInputElements::third_app_calldata_inverses
FF third_app_calldata_inverses
Definition databus_lookup_relation_consistency.test.cpp:59

DatabusInputElements::first_app_calldata
FF first_app_calldata
Definition databus_lookup_relation_consistency.test.cpp:47

DatabusInputElements::return_data
FF return_data
Definition databus_lookup_relation_consistency.test.cpp:62

DatabusInputElements::third_app_calldata
FF third_app_calldata
Definition databus_lookup_relation_consistency.test.cpp:57

DatabusInputElements::q_o
FF q_o
Definition databus_lookup_relation_consistency.test.cpp:37

bb::RelationParameters
Container for parameters used by the grand product (permutation, lookup) Honk relations.
Definition relation_parameters.hpp:18

bb::RelationParameters::beta
T beta
Definition relation_parameters.hpp:27

bb::RelationParameters::gamma
T gamma
Definition relation_parameters.hpp:28

bb::RelationParameters::get_random
static RelationParameters get_random()
Definition relation_parameters.hpp:69

bb::field< bb::Bn254FrParams >

bb::field::invert
constexpr field invert() const noexcept
Definition field_impl.hpp:386

bb::field< Bn254FrParams >::random_element
static field random_element(numeric::RNG *engine=nullptr) noexcept
Definition field_impl.hpp:777