translator_permutation_relation.hpp

#pragma once
#include "barretenberg/relations/relation_types.hpp"
 
namespace proof_system {
 
template <typename FF_> class GoblinTranslatorPermutationRelationImpl {
  public:
    using FF = FF_;
    // 1 + polynomial degree of this relation
    static constexpr size_t RELATION_LENGTH = 7;
 
    static constexpr std::array<size_t, 2> SUBRELATION_PARTIAL_LENGTHS{
        7, // grand product construction sub-relation
        3  // left-shiftable polynomial sub-relation
    };
 
    inline static auto& get_grand_product_polynomial(auto& in) { return in.z_perm; }
    inline static auto& get_shifted_grand_product_polynomial(auto& in) { return in.z_perm_shift; }
 
    template <typename Accumulator, typename AllEntities, typename Parameters>
    inline static Accumulator compute_grand_product_numerator(const AllEntities& in, const Parameters& params)
    {
        using View = typename Accumulator::View;
 
        auto concatenated_range_constraints_0 = View(in.concatenated_range_constraints_0);
        auto concatenated_range_constraints_1 = View(in.concatenated_range_constraints_1);
        auto concatenated_range_constraints_2 = View(in.concatenated_range_constraints_2);
        auto concatenated_range_constraints_3 = View(in.concatenated_range_constraints_3);
 
        auto ordered_extra_range_constraints_numerator = View(in.ordered_extra_range_constraints_numerator);
 
        const auto& gamma = params.gamma;
        return (concatenated_range_constraints_0 + gamma) * (concatenated_range_constraints_1 + gamma) *
               (concatenated_range_constraints_2 + gamma) * (concatenated_range_constraints_3 + gamma) *
               (ordered_extra_range_constraints_numerator + gamma);
    }
 
    template <typename Accumulator, typename AllEntities, typename Parameters>
    inline static Accumulator compute_grand_product_denominator(const AllEntities& in, const Parameters& params)
    {
        using View = typename Accumulator::View;
 
        auto ordered_range_constraints_0 = View(in.ordered_range_constraints_0);
        auto ordered_range_constraints_1 = View(in.ordered_range_constraints_1);
        auto ordered_range_constraints_2 = View(in.ordered_range_constraints_2);
        auto ordered_range_constraints_3 = View(in.ordered_range_constraints_3);
        auto ordered_range_constraints_4 = View(in.ordered_range_constraints_4);
 
        const auto& gamma = params.gamma;
 
        return (ordered_range_constraints_0 + gamma) * (ordered_range_constraints_1 + gamma) *
               (ordered_range_constraints_2 + gamma) * (ordered_range_constraints_3 + gamma) *
               (ordered_range_constraints_4 + gamma);
    }
    template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
    static void accumulate(ContainerOverSubrelations& accumulators,
                           const AllEntities& in,
                           const Parameters& params,
                           const FF& scaling_factor);
};
 
template <typename FF>
using GoblinTranslatorPermutationRelation = Relation<GoblinTranslatorPermutationRelationImpl<FF>>;
 
} // namespace proof_system