circuit_builder_base.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: not started, auditors: [], date: YYYY-MM-DD }
// external_1:  { status: not started, auditors: [], date: YYYY-MM-DD }
// external_2:  { status: not started, auditors: [], date: YYYY-MM-DD }
// =====================
 
#pragma once
#include "barretenberg/common/assert.hpp"
#include "barretenberg/ecc/curves/bn254/bn254.hpp"
#include "barretenberg/ecc/curves/bn254/fr.hpp"
#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
#include "barretenberg/honk/execution_trace/gate_data.hpp"
#include "barretenberg/public_input_component/public_component_key.hpp"
#include "barretenberg/serialize/msgpack.hpp"
#include "pairing_points_tagging.hpp"
#include <utility>
 
#include <algorithm>
#include <unordered_map>
 
namespace bb {
static constexpr uint32_t DUMMY_TAG = 0;
 
template <typename FF_> class CircuitBuilderBase {
  public:
    using FF = FF_;
    using EmbeddedCurve = curve::Grumpkin;
 
  private:
    // A container for all of the witness values used by the circuit
    std::vector<FF> variables;
 
    std::vector<uint32_t> _public_inputs;
 
    bool _public_inputs_finalized = false; // Addition of new public inputs disallowed after this is set to true.
 
    // index of next variable in equivalence class, which is `REAL_VARIABLE` if the current index is last in the cycle
    // representing copy constraints containing the index. The name comes from the fact that if `next_var_index[idx] ==
    // REAL_VARIABLE`, then `real_variable_index[idx] == idx`. See the commentary around `real_variable_index` for more
    // details.
    std::vector<uint32_t> next_var_index;
    // index of previous variable in equivalence class, which is `FIRST_VARIABLE_IN_CLASS` if the current index is the
    // first in the cycle representing copy constraints containing the index (and in particular if the current index is
    // not contained in any copy constraints).
    std::vector<uint32_t> prev_var_index;
 
    static constexpr uint32_t REAL_VARIABLE = UINT32_MAX - 1;
    static constexpr uint32_t FIRST_VARIABLE_IN_CLASS = UINT32_MAX - 2;
 
    // Index at which we store a witness constrained to be equal to 0
    uint32_t _zero_idx = 0;
 
    size_t _num_gates = 0;
 
    void update_real_variable_indices(uint32_t index, uint32_t new_real_index);
 
  protected:
    void set_zero_idx(uint32_t value) { _zero_idx = value; }
 
    uint32_t get_first_variable_in_class(uint32_t index) const;
 
    void assert_valid_variables(const std::vector<uint32_t>& variable_indices);
 
    std::unordered_map<uint32_t, uint32_t> _tau;
 
  public:
    std::vector<uint32_t> real_variable_index;
    std::vector<uint32_t> real_variable_tags;
    uint32_t current_tag = DUMMY_TAG;
 
    CircuitBuilderBase(size_t size_hint = 0, bool is_write_vk_mode = false);
 
    CircuitBuilderBase(const CircuitBuilderBase& other) = default;
    CircuitBuilderBase(CircuitBuilderBase&& other) noexcept = default;
    CircuitBuilderBase& operator=(const CircuitBuilderBase& other) = default;
    CircuitBuilderBase& operator=(CircuitBuilderBase&& other) noexcept = default;
    virtual ~CircuitBuilderBase() = default;
 
    bool operator==(const CircuitBuilderBase& other) const = default;
 
    virtual size_t get_num_finalized_gates() const;
    virtual size_t get_num_variables() const;
 
    // Get the current number of gates in the circuit
    size_t num_gates() const { return _num_gates; }
 
    // Increment the gate count by the specified amount
    void increment_num_gates(size_t count = 1) { _num_gates += count; }
 
    // Get the permutation on variable tags
    const std::unordered_map<uint32_t, uint32_t>& tau() const { return _tau; }
 
    // Non-owning getter for the index at which a fixed witness 0 is stored
    uint32_t zero_idx() const { return _zero_idx; }
 
    virtual size_t get_num_constant_gates() const = 0;
 
    const std::vector<FF>& get_variables() const { return variables; }
 
    inline FF get_variable(const uint32_t index) const
    {
        BB_ASSERT_DEBUG(real_variable_index.size() > index);
        BB_ASSERT_DEBUG(variables.size() > real_variable_index[index]);
        return variables[real_variable_index[index]];
    }
 
    inline void set_variable(const uint32_t index, const FF& value)
    {
        BB_ASSERT(is_write_vk_mode());
        BB_ASSERT_DEBUG(real_variable_index.size() > index);
        BB_ASSERT_DEBUG(variables.size() > real_variable_index[index]);
        variables[real_variable_index[index]] = value;
    }
 
    const std::vector<uint32_t>& public_inputs() const { return _public_inputs; };
 
    void finalize_public_inputs() { _public_inputs_finalized = true; }
 
    void initialize_public_inputs(const std::vector<uint32_t>& public_inputs) { this->_public_inputs = public_inputs; }
 
    virtual uint32_t add_variable(const FF& in);
 
    // Disallow add_variable for non-FF types to prevent implicit conversions (specifically, using indices rather
    // than values)
    template <typename OT> uint32_t add_variable(const OT& in) = delete;
 
    virtual uint32_t add_public_variable(const FF& in);
 
    // Disallow add_public_variable for non-FF types to prevent implicit conversions (specifically, using indices rather
    // than values)
    template <typename OT> uint32_t add_public_variable(const OT& in) = delete;
 
    virtual uint32_t set_public_input(uint32_t witness_index);
    virtual void assert_equal(uint32_t a_idx, uint32_t b_idx, std::string const& msg = "assert_equal");
 
    size_t get_circuit_subgroup_size(size_t num_gates) const;
 
    size_t num_public_inputs() const { return _public_inputs.size(); }
 
    // ========================================================================================
    // TOOLING: Debug, Error Tracking, and Circuit Export
    // ========================================================================================
 
  private:
    bool _failed = false;
    std::string _err;
 
    // True if we are writing a vk; used to disable certain warnings
    bool _is_write_vk_mode = false;
 
  protected:
    std::unordered_map<uint32_t, std::string> variable_names;
 
  public:
    virtual void set_variable_name(uint32_t index, const std::string& name);
 
    virtual msgpack::sbuffer export_circuit();
 
    bool failed() const;
    const std::string& err() const;
 
    void failure(std::string msg);
 
    mutable PairingPointsTagging pairing_points_tagging;
 
    bool is_write_vk_mode() const { return _is_write_vk_mode; }
};
 
template <typename FF> struct CircuitSchemaInternal {
    std::string modulus;
    std::vector<uint32_t> public_inps;
    std::unordered_map<uint32_t, std::string> vars_of_interest;
    std::vector<FF> variables;
    std::vector<std::vector<std::vector<FF>>> selectors;
    std::vector<std::vector<std::vector<uint32_t>>> wires;
    std::vector<uint32_t> real_variable_index;
    std::vector<std::vector<std::vector<FF>>> lookup_tables;
    std::vector<uint32_t> real_variable_tags;
    std::unordered_map<uint32_t, uint64_t> range_tags;
    std::vector<std::vector<std::vector<uint32_t>>> rom_records;
    std::vector<std::vector<std::array<uint32_t, 2>>> rom_states;
    std::vector<std::vector<std::vector<uint32_t>>> ram_records;
    std::vector<std::vector<uint32_t>> ram_states;
    bool circuit_finalized;
    MSGPACK_FIELDS(modulus,
                   public_inps,
                   vars_of_interest,
                   variables,
                   selectors,
                   wires,
                   real_variable_index,
                   lookup_tables,
                   real_variable_tags,
                   range_tags,
                   rom_records,
                   rom_states,
                   ram_records,
                   ram_states,
                   circuit_finalized);
};
// ========================================================================================
} // namespace bb
 
// TODO(#217)(Cody): This will need updating based on the approach we take to ensure no multivariate is zero.