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 <utility>
 
#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.
 
    // true if we have dummy witnesses (in the write_vk case)
    bool has_dummy_witnesses_ = false;
 
    // index of next variable in equivalence class (=REAL_VARIABLE if you're last)
    std::vector<uint32_t> next_var_index;
    // index of  previous variable in equivalence class (=FIRST if you're in a cycle alone)
    std::vector<uint32_t> prev_var_index;
 
    bool _failed = false;
    std::string _err;
 
    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;
 
  protected:
    std::unordered_map<uint32_t, std::string> variable_names;
 
    void set_zero_idx(uint32_t value) { _zero_idx = value; }
 
  public:
    size_t num_gates = 0;
 
    // The permutation on variable tags. See
    // https://github.com/AztecProtocol/plonk-with-lookups-private/blob/new-stuff/GenPermuations.pdf
    // DOCTODO(#231): replace with the relevant wiki link.
    std::map<uint32_t, uint32_t> tau;
 
    // The "real_variable_index" acts as a map from a "witness index" (e.g. the one stored by a stdlib object) to an
    // index into the variables array. This extra layer of indirection is used to support copy constraints by allowing,
    // for example, two witnesses with differing witness indices to have the same "real variable index" and thus the
    // same witness value. If the witness is not involved in any copy constraints, then real_variable_index[index] ==
    // index, i.e. it is the identity map.
    std::vector<uint32_t> real_variable_index;
    std::vector<uint32_t> real_variable_tags;
    uint32_t current_tag = DUMMY_TAG;
 
  public:
    CircuitBuilderBase(size_t size_hint = 0, bool has_dummy_witnesses = 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 has_dummy_witnesses() const { return has_dummy_witnesses_; }
    bool operator==(const CircuitBuilderBase& other) const = default;
 
    virtual size_t get_num_finalized_gates() const;
    virtual size_t get_estimated_num_finalized_gates() const;
    virtual void print_num_estimated_finalized_gates() const;
    virtual size_t get_num_variables() const;
 
    // Non-owning getter for the index at which a fixed witness 0 is stored
    uint32_t zero_idx() const { return _zero_idx; }
 
    virtual void create_add_gate(const add_triple_<FF>& in) = 0;
    virtual void create_mul_gate(const mul_triple_<FF>& in) = 0;
    virtual void create_bool_gate(const uint32_t a) = 0;
    virtual void create_poly_gate(const poly_triple_<FF>& in) = 0;
    virtual size_t get_num_constant_gates() const = 0;
 
    const std::vector<FF>& get_variables() const { return variables; }
 
    uint32_t get_first_variable_in_class(uint32_t index) const;
    void update_real_variable_indices(uint32_t index, uint32_t new_real_index);
 
    inline FF get_variable(const uint32_t index) const
    {
        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)
    {
        ASSERT_DEBUG(variables.size() > real_variable_index[index]);
        variables[real_variable_index[index]] = value;
    }
 
    inline const FF& get_variable_reference(const uint32_t index) const
    {
        ASSERT_DEBUG(variables.size() > index);
        return variables[real_variable_index[index]];
    }
 
    uint32_t get_public_input_index(const uint32_t witness_index) const;
 
    FF get_public_input(const uint32_t index) const;
 
    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);
 
    virtual void set_variable_name(uint32_t index, const std::string& name);
 
    virtual msgpack::sbuffer export_circuit();
 
    virtual uint32_t add_public_variable(const FF& in);
 
    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(); }
 
    // Check whether each variable index points to a witness in the composer
    //
    // Any variable whose index does not point to witness value is deemed invalid.
    //
    // This implicitly checks whether a variable index
    // is equal to IS_CONSTANT; assuming that we will never have
    // uint32::MAX number of variables
    void assert_valid_variables(const std::vector<uint32_t>& variable_indices);
 
    bool failed() const;
    const std::string& err() const;
 
    void failure(std::string msg);
};
 
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.