translator_permutation_relation.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Planned, auditors: [], 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 TranslatorPermutationRelationImpl {
  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
    };
 
    template <typename AllEntities> inline static bool skip(const AllEntities& in)
    {
        // If z_perm == z_perm_shift, this implies that none of the wire values for the present input are involved in
        // non-trivial copy constraints.
        return (in.z_perm - in.z_perm_shift).is_zero();
    }
 
    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;
        using ParameterView = Parameters::DataType;
 
        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);
 
        auto lagrange_masking = View(in.lagrange_masking);
        auto lagrange_ordered_masking = View(in.lagrange_ordered_masking);
        const auto& gamma = ParameterView(params.gamma);
        const auto& beta = ParameterView(params.beta);
        // First 4 factors use scattered masking (lagrange_masking), last factor uses contiguous masking
        auto chosen_set = lagrange_masking * beta;
        auto chosen_set2 = lagrange_ordered_masking * beta;
        return (concatenated_range_constraints_0 + chosen_set + gamma) *
               (concatenated_range_constraints_1 + chosen_set + gamma) *
               (concatenated_range_constraints_2 + chosen_set + gamma) *
               (concatenated_range_constraints_3 + chosen_set + gamma) *
               (ordered_extra_range_constraints_numerator + chosen_set2 + 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;
        using ParameterView = Parameters::DataType;
 
        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);
 
        auto lagrange_ordered_masking = View(in.lagrange_ordered_masking);
 
        const auto& gamma = ParameterView(params.gamma);
        const auto& beta = ParameterView(params.beta);
        // All 5 factors use contiguous masking at the end (lagrange_ordered_masking)
        auto chosen_set = lagrange_ordered_masking * beta;
        return (ordered_range_constraints_0 + chosen_set + gamma) * (ordered_range_constraints_1 + chosen_set + gamma) *
               (ordered_range_constraints_2 + chosen_set + gamma) * (ordered_range_constraints_3 + chosen_set + gamma) *
               (ordered_range_constraints_4 + chosen_set + 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 TranslatorPermutationRelation = Relation<TranslatorPermutationRelationImpl<FF>>;
 
} // namespace bb