circuit_builder_base_impl.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Complete, auditors: [Luke, Raju], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
#include "barretenberg/common/assert.hpp"
#include "barretenberg/serialize/msgpack_impl.hpp"
#include "circuit_builder_base.hpp"
 
namespace bb {
template <typename FF_>
CircuitBuilderBase<FF_>::CircuitBuilderBase(bool is_write_vk_mode)
    : _is_write_vk_mode(is_write_vk_mode)
{}
 
template <typename FF_> size_t CircuitBuilderBase<FF_>::get_num_finalized_gates() const
{
    return _num_gates;
}
 
template <typename FF_> size_t CircuitBuilderBase<FF_>::get_num_variables() const
{
    return variables.size();
}
 
template <typename FF_> uint32_t CircuitBuilderBase<FF_>::get_first_variable_in_class(uint32_t index) const
{
    while (prev_var_index[index] != FIRST_VARIABLE_IN_CLASS) {
        index = prev_var_index[index];
    }
    return index;
}
 
template <typename FF_>
void CircuitBuilderBase<FF_>::update_real_variable_indices(uint32_t index, uint32_t new_real_index)
{
    auto cur_index = index;
    do {
        real_variable_index[cur_index] = new_real_index;
        cur_index = next_var_index[cur_index];
    } while (cur_index != REAL_VARIABLE);
}
 
template <typename FF_> uint32_t CircuitBuilderBase<FF_>::add_variable(const FF& in)
{
    variables.emplace_back(in);
    const uint32_t index = static_cast<uint32_t>(variables.size()) - 1U;
    real_variable_index.emplace_back(index);
    next_var_index.emplace_back(REAL_VARIABLE);
    prev_var_index.emplace_back(FIRST_VARIABLE_IN_CLASS);
    real_variable_tags.emplace_back(DEFAULT_TAG);
    return index;
}
 
// Only used in SMT verification
template <typename FF_> void CircuitBuilderBase<FF_>::set_variable_name(uint32_t index, const std::string& name)
{
    BB_ASSERT_DEBUG(variables.size() > index);
    uint32_t first_idx = get_first_variable_in_class(index);
 
    if (variable_names.contains(first_idx)) {
        failure("Attempted to assign a name to a variable that already has a name");
        return;
    }
    variable_names.insert({ first_idx, name });
}
 
template <typename FF_> size_t CircuitBuilderBase<FF_>::get_circuit_subgroup_size(const size_t _num_gates) const
{
    auto log2_n = static_cast<size_t>(numeric::get_msb(_num_gates));
    if ((1UL << log2_n) != (_num_gates)) {
        ++log2_n;
    }
    return 1UL << log2_n;
}
 
template <typename FF_> uint32_t CircuitBuilderBase<FF_>::add_public_variable(const FF& in)
{
    const uint32_t index = add_variable(in);
    BB_ASSERT_EQ(_public_inputs_finalized, false, "Cannot add to public inputs after they have been finalized.");
    _public_inputs.emplace_back(index);
    return index;
}
 
template <typename FF_> uint32_t CircuitBuilderBase<FF_>::set_public_input(const uint32_t witness_index)
{
    BB_ASSERT_LT(witness_index, get_num_variables(), "set_public_input: witness_index out of range");
    for (const uint32_t public_input : public_inputs()) {
        if (public_input == witness_index) {
            if (!failed()) {
                failure("Attempted to set a public input that is already public!");
            }
            return 0;
        }
    }
    uint32_t public_input_index = static_cast<uint32_t>(num_public_inputs());
    BB_ASSERT_EQ(_public_inputs_finalized, false, "Cannot add to public inputs after they have been finalized.");
    _public_inputs.emplace_back(witness_index);
 
    return public_input_index;
}
 
template <typename FF>
void CircuitBuilderBase<FF>::assert_equal(const uint32_t a_variable_idx,
                                          const uint32_t b_variable_idx,
                                          std::string const& msg)
{
    assert_valid_variables({ a_variable_idx, b_variable_idx });
    bool values_equal = (get_variable(a_variable_idx) == get_variable(b_variable_idx));
    if (!values_equal && !failed()) {
        failure(msg);
    }
    uint32_t a_real_idx = real_variable_index[a_variable_idx];
    uint32_t b_real_idx = real_variable_index[b_variable_idx];
    // If a==b is already enforced, exit method
    if (a_real_idx == b_real_idx) {
        return;
    }
    // Otherwise update the real_idx of b-chain members to that of a
 
    auto b_start_idx = get_first_variable_in_class(b_variable_idx);
    update_real_variable_indices(b_start_idx, a_real_idx);
    // Now merge equivalence classes of a and b by tying last (= real) element of b-chain to first element of a-chain
    auto a_start_idx = get_first_variable_in_class(a_variable_idx);
    next_var_index[b_real_idx] = a_start_idx;
    prev_var_index[a_start_idx] = b_real_idx;
    bool no_tag_clash =
        (real_variable_tags[a_real_idx] == DEFAULT_TAG || real_variable_tags[b_real_idx] == DEFAULT_TAG ||
         real_variable_tags[a_real_idx] == real_variable_tags[b_real_idx]);
    if (!no_tag_clash && !failed()) {
        failure(msg);
    }
    if (real_variable_tags[a_real_idx] == DEFAULT_TAG) {
        real_variable_tags[a_real_idx] = real_variable_tags[b_real_idx];
    }
}
 
template <typename FF_>
void CircuitBuilderBase<FF_>::assert_valid_variables([[maybe_unused]] const std::vector<uint32_t>& variable_indices)
{
#ifndef NDEBUG
    for (const auto& variable_index : variable_indices) {
        BB_ASSERT_LT(variable_index, variables.size());
    }
#endif
}
 
template <typename FF_> bool CircuitBuilderBase<FF_>::failed() const
{
    return _failed;
}
 
template <typename FF_> const std::string& CircuitBuilderBase<FF_>::err() const
{
    return _err;
}
 
template <typename FF_> void CircuitBuilderBase<FF_>::failure(std::string msg)
{
#ifndef FUZZING_DISABLE_WARNINGS
    if (!_is_write_vk_mode) {
        // Not a catch-all error log. We have a builder failure when we have real witnesses which is a mistake.
        info("(Experimental) WARNING: Builder failure when we have real witnesses! Ignore if writing vk.");
    }
#endif
    _failed = true;
    _err = msg;
}
} // namespace bb