arithmetic_constraints.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Complete, auditors: [Federico], commit: 2094fd1467dd9a94803b2c5007cf60ac357aa7d2 }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
#include "barretenberg/common/assert.hpp"
#include "barretenberg/honk/execution_trace/gate_data.hpp"
#include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp"
#include "barretenberg/stdlib/primitives/witness/witness.hpp"
#include "barretenberg/stdlib_circuit_builders/mega_circuit_builder.hpp"
#include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
#include <vector>
 
namespace acir_format {
 
using namespace bb;
using namespace bb::stdlib;
 
using QuadConstraint = mul_quad_<bb::fr>;
 
struct BilinearConstraint {
    uint32_t a;
    uint32_t b;
    uint32_t c;
    uint32_t d;
    bb::fr q_m; // first product (a·b) selector
    bb::fr q_l;
    bb::fr q_r;
    bb::fr q_o;
    bb::fr q_4;
    bb::fr q_5; // second product (a·c) selector
    bb::fr q_c;
 
    friend bool operator==(BilinearConstraint const& lhs, BilinearConstraint const& rhs) = default;
};
 
struct BatchedEqCheckConstraint {
    uint32_t a;
    uint32_t b;
    uint32_t c;
    uint32_t d;
    bb::fr q_l;
    bb::fr q_r;
    bb::fr q_o;
    bb::fr q_4;
    bb::fr q_c; // batched-eq-half-1 constant
    bb::fr q_m; // batched-eq-half-2 constant
 
    friend bool operator==(BatchedEqCheckConstraint const& lhs, BatchedEqCheckConstraint const& rhs) = default;
};
 
class BigQuadConstraint : public std::vector<QuadConstraint> {
  public:
    using Base = std::vector<QuadConstraint>;
    using Base::Base; // Inherit all constructors from std::vector
 
    // Explicitly define vector copy constructor (not inherited by default)
    BigQuadConstraint(const std::vector<QuadConstraint>& fields)
        : Base(fields)
    {}
};
 
template <typename Builder> void set_zero_idx(const Builder& builder, QuadConstraint& mul_quad);
 
template <typename Builder>
void check_mul_add_gate(Builder& builder,
                        const QuadConstraint& mul_quad,
                        const typename Builder::FF next_wire_w4 = Builder::FF::zero());
 
template <typename Builder>
void check_bilinear_batched_eq_gate(Builder& builder,
                                    const bilinear_batched_eq_gate_<typename Builder::FF>& bilinear_batched_eq);
 
template <typename Builder> void create_quad_constraint(Builder& builder, QuadConstraint& mul_quad);
 
// clang-format off
// clang-format on
template <typename Builder> void create_big_quad_constraint(Builder& builder, BigQuadConstraint& big_constraint);
 
template <typename Builder> void create_bilinear_constraint(Builder& builder, const BilinearConstraint& constraint);
 
template <typename Builder>
void create_batched_eq_check_constraint(Builder& builder, const BatchedEqCheckConstraint& constraint);
 
} // namespace acir_format