gen_perm_sort_relation.hpp

#pragma once
#include "barretenberg/relations/relation_types.hpp"
 
namespace proof_system {
 
template <typename FF_> class GenPermSortRelationImpl {
  public:
    using FF = FF_;
 
    static constexpr std::array<size_t, 4> SUBRELATION_PARTIAL_LENGTHS{
        6, // range constrain sub-relation 1
        6, // range constrain sub-relation 2
        6, // range constrain sub-relation 3
        6  // range constrain sub-relation 4
    };
 
    template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
    inline static void accumulate(ContainerOverSubrelations& accumulators,
                                  const AllEntities& in,
                                  const Parameters&,
                                  const FF& scaling_factor)
    {
        using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
        using View = typename Accumulator::View;
        auto w_1 = View(in.w_l);
        auto w_2 = View(in.w_r);
        auto w_3 = View(in.w_o);
        auto w_4 = View(in.w_4);
        auto w_1_shift = View(in.w_l_shift);
        auto q_sort = View(in.q_sort);
 
        static const FF minus_one = FF(-1);
        static const FF minus_two = FF(-2);
        static const FF minus_three = FF(-3);
 
        // Compute wire differences
        auto delta_1 = w_2 - w_1;
        auto delta_2 = w_3 - w_2;
        auto delta_3 = w_4 - w_3;
        auto delta_4 = w_1_shift - w_4;
 
        // Contribution (1)
        auto tmp_1 = delta_1;
        tmp_1 *= (delta_1 + minus_one);
        tmp_1 *= (delta_1 + minus_two);
        tmp_1 *= (delta_1 + minus_three);
        tmp_1 *= q_sort;
        tmp_1 *= scaling_factor;
        std::get<0>(accumulators) += tmp_1;
 
        // Contribution (2)
        auto tmp_2 = delta_2;
        tmp_2 *= (delta_2 + minus_one);
        tmp_2 *= (delta_2 + minus_two);
        tmp_2 *= (delta_2 + minus_three);
        tmp_2 *= q_sort;
        tmp_2 *= scaling_factor;
        std::get<1>(accumulators) += tmp_2;
 
        // Contribution (3)
        auto tmp_3 = delta_3;
        tmp_3 *= (delta_3 + minus_one);
        tmp_3 *= (delta_3 + minus_two);
        tmp_3 *= (delta_3 + minus_three);
        tmp_3 *= q_sort;
        tmp_3 *= scaling_factor;
        std::get<2>(accumulators) += tmp_3;
 
        // Contribution (4)
        auto tmp_4 = delta_4;
        tmp_4 *= (delta_4 + minus_one);
        tmp_4 *= (delta_4 + minus_two);
        tmp_4 *= (delta_4 + minus_three);
        tmp_4 *= q_sort;
        tmp_4 *= scaling_factor;
        std::get<3>(accumulators) += tmp_4;
    };
};
 
template <typename FF> using GenPermSortRelation = Relation<GenPermSortRelationImpl<FF>>;
 
} // namespace proof_system