ultra_arithmetic_relation.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/relations/relation_types.hpp"
 
namespace bb {
 
template <typename FF_> class ArithmeticRelationImpl {
  public:
    using FF = FF_;
 
    static constexpr std::array<size_t, 2> SUBRELATION_PARTIAL_LENGTHS{
        6, // primary arithmetic sub-relation
        5  // secondary arithmetic sub-relation
    };
 
    template <typename AllEntities> inline static bool skip(const AllEntities& in) { return in.q_arith.is_zero(); }
 
    template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
    inline static void accumulate(ContainerOverSubrelations& evals,
                                  const AllEntities& in,
                                  BB_UNUSED const Parameters& params,
                                  const FF& scaling_factor)
    {
        using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
        using CoefficientAccumulator = typename Accumulator::CoefficientAccumulator;
 
        auto w_l_m = CoefficientAccumulator(in.w_l);
        auto w_4_m = CoefficientAccumulator(in.w_4);
        auto q_arith_m = CoefficientAccumulator(in.q_arith);
        auto q_m_m = CoefficientAccumulator(in.q_m);
 
        auto q_arith_sub_1 = q_arith_m - FF(1);
        auto scaled_q_arith = q_arith_m * scaling_factor;
        // Subrelation 1
        {
            using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
 
            auto w_4_shift_m = CoefficientAccumulator(in.w_4_shift);
            auto w_r_m = CoefficientAccumulator(in.w_r);
            auto w_o_m = CoefficientAccumulator(in.w_o);
            auto q_l_m = CoefficientAccumulator(in.q_l);
            auto q_r_m = CoefficientAccumulator(in.q_r);
            auto q_o_m = CoefficientAccumulator(in.q_o);
            auto q_4_m = CoefficientAccumulator(in.q_4);
            auto q_c_m = CoefficientAccumulator(in.q_c);
 
            static const FF neg_half = FF(-2).invert();
 
            auto tmp0 = Accumulator(w_r_m * w_l_m * neg_half) * Accumulator((q_arith_m - 3) * q_m_m);
            auto tmp1 = (q_l_m * w_l_m) + (q_r_m * w_r_m) + (q_o_m * w_o_m) + (q_4_m * w_4_m) + q_c_m;
            tmp1 += q_arith_sub_1 * w_4_shift_m;
 
            std::get<0>(evals) += (tmp0 + Accumulator(tmp1)) * Accumulator(scaled_q_arith);
        }
        // Subrelation 2
        {
            using ShortAccumulator = std::tuple_element_t<1, ContainerOverSubrelations>;
 
            auto w_l_shift_m = CoefficientAccumulator(in.w_l_shift);
 
            auto tmp_0 = w_l_m + w_4_m - w_l_shift_m + q_m_m;
            auto tmp_1 = tmp_0 * (q_arith_m - FF(2));
            auto tmp_2 = q_arith_sub_1 * scaled_q_arith;
            std::get<1>(evals) += ShortAccumulator(tmp_1) * ShortAccumulator(tmp_2);
        };
    };
};
 
template <typename FF> using ArithmeticRelation = Relation<ArithmeticRelationImpl<FF>>;
} // namespace bb