delta_range_constraint_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 DeltaRangeConstraintRelationImpl {
  public:
    using FF = FF_;
 
    static constexpr std::array<size_t, 4> SUBRELATION_PARTIAL_LENGTHS{
        6, // sub-relation 1: D_0 = w_2 - w_1
        6, // sub-relation 2: D_1 = w_3 - w_2
        6, // sub-relation 3: D_2 = w_4 - w_3
        6  // sub-relation 4: D_3 = w_1_shifst - w_4
    };
 
    template <typename AllEntities> inline static bool skip(const AllEntities& in)
    {
        return in.q_delta_range.is_zero();
    }
 
    template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
    inline static void accumulate(ContainerOverSubrelations& accumulators,
                                  const AllEntities& in,
                                  BB_UNUSED const Parameters&,
                                  const FF& scaling_factor)
    {
        using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
        using CoefficientAccumulator = typename Accumulator::CoefficientAccumulator;
 
        auto w_1 = CoefficientAccumulator(in.w_l);
        auto w_2 = CoefficientAccumulator(in.w_r);
        auto w_3 = CoefficientAccumulator(in.w_o);
        auto w_4 = CoefficientAccumulator(in.w_4);
        auto w_1_shift = CoefficientAccumulator(in.w_l_shift);
        auto q_delta_range_m = CoefficientAccumulator(in.q_delta_range);
 
        auto q_delta_range_scaled_m = q_delta_range_m * scaling_factor;
        Accumulator q_delta_range_scaled(q_delta_range_scaled_m);
 
        // Compute wire differences
        auto delta_1 = Accumulator(w_2 - w_1);
        auto delta_2 = Accumulator(w_3 - w_2);
        auto delta_3 = Accumulator(w_4 - w_3);
        auto delta_4 = Accumulator(w_1_shift - w_4);
 
        // Polynomial trick: if T = (D - 3) * D, then T * (T + 2) == D * (D - 1) * (D - 2) * (D - 3)
 
        // Contribution (1)
        auto tmp_1 = (delta_1 - FF(3)) * delta_1;
        tmp_1 *= (tmp_1 + FF(2));
        tmp_1 *= q_delta_range_scaled;
        std::get<0>(accumulators) += tmp_1;
 
        // Contribution (2)
        auto tmp_2 = (delta_2 - FF(3)) * delta_2;
        tmp_2 *= (tmp_2 + FF(2));
        tmp_2 *= q_delta_range_scaled;
        std::get<1>(accumulators) += tmp_2;
 
        // Contribution (3)
        auto tmp_3 = (delta_3 - FF(3)) * delta_3;
        tmp_3 *= (tmp_3 + FF(2));
        tmp_3 *= q_delta_range_scaled;
        std::get<2>(accumulators) += tmp_3;
 
        // Contribution (4)
        auto tmp_4 = (delta_4 - FF(3)) * delta_4;
        tmp_4 *= (tmp_4 + FF(2));
        tmp_4 *= q_delta_range_scaled;
        std::get<3>(accumulators) += tmp_4;
    };
};
 
template <typename FF> using DeltaRangeConstraintRelation = Relation<DeltaRangeConstraintRelationImpl<FF>>;
 
} // namespace bb