multilinear_batching_relation.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: not started, auditors: [], date: YYYY-MM-DD }
// external_1:  { status: not started, auditors: [], date: YYYY-MM-DD }
// external_2:  { status: not started, auditors: [], date: YYYY-MM-DD }
// =====================
 
#pragma once
#include "barretenberg/relations/relation_parameters.hpp"
#include "barretenberg/relations/relation_types.hpp"
 
namespace bb {
 
template <typename FF_> class MultilinearBatchingAccumulatorRelationImpl {
  public:
    using FF = FF_;
 
    static constexpr std::array<size_t, 2> SUBRELATION_PARTIAL_LENGTHS{
        3, // primary arithmetic sub-relation
        3, // secondary arithmetic sub-relation
    };
 
    static constexpr std::array<bool, 2> SUBRELATION_LINEARLY_INDEPENDENT = { false, false };
 
    template <typename AllEntities> inline static bool skip(const AllEntities& in)
    {
        return (in.w_non_shifted_accumulator.is_zero() && in.w_shifted_accumulator.is_zero()) ||
               (in.w_evaluations_accumulator.is_zero());
    }
 
    template <typename ContainerOverSubrelations, typename AllEntities>
    inline static void accumulate(ContainerOverSubrelations& evals,
                                  const AllEntities& in,
                                  [[maybe_unused]] const RelationParameters<FF>& relation_parameters = {},
                                  [[maybe_unused]] const FF& scaling_factor = {})
    {
        using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
 
        auto w_non_shifted_accumulator = Accumulator(in.w_non_shifted_accumulator);
        auto w_evaluations_accumulator = Accumulator(in.w_evaluations_accumulator);
        auto w_shifted_accumulator = Accumulator(in.w_shifted_accumulator);
 
        std::get<0>(evals) += (w_non_shifted_accumulator * w_evaluations_accumulator);
        std::get<1>(evals) += (w_shifted_accumulator * w_evaluations_accumulator);
    };
};
template <typename FF_> class MultilinearBatchingInstanceRelationImpl {
  public:
    using FF = FF_;
 
    static constexpr std::array<size_t, 2> SUBRELATION_PARTIAL_LENGTHS{
        3, // primary arithmetic sub-relation
        3, // secondary arithmetic sub-relation
    };
 
    static constexpr std::array<bool, 2> SUBRELATION_LINEARLY_INDEPENDENT = { false, false };
 
    template <typename AllEntities> static bool skip(const AllEntities& in)
    {
        return (in.w_non_shifted_accumulator.is_zero() && in.w_non_shifted_instance.is_zero() &&
                in.w_shifted_accumulator.is_zero() && in.w_shifted_instance.is_zero()) ||
               (in.w_evaluations_accumulator.is_zero() && in.w_evaluations_instance.is_zero());
    }
 
    template <typename ContainerOverSubrelations, typename AllEntities>
    static void accumulate(ContainerOverSubrelations& evals,
                           const AllEntities& in,
                           [[maybe_unused]] const RelationParameters<FF>& relation_parameters = {},
                           [[maybe_unused]] const FF& scaling_factor = {})
    {
        using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
 
        auto w_non_shifted_instance = Accumulator(in.w_non_shifted_instance);
        auto w_evaluations_instance = Accumulator(in.w_evaluations_instance);
        auto w_shifted_instance = Accumulator(in.w_shifted_instance);
 
        std::get<0>(evals) += (w_non_shifted_instance * w_evaluations_instance);
        std::get<1>(evals) += (w_shifted_instance * w_evaluations_instance);
    };
};
 
template <typename FF>
using MultilinearBatchingInstanceRelation = Relation<MultilinearBatchingInstanceRelationImpl<FF>>;
template <typename FF>
using MultilinearBatchingAccumulatorRelation = Relation<MultilinearBatchingAccumulatorRelationImpl<FF>>;
} // namespace bb