multilinear_batching_relation.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Complete, auditors: [Sergei], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
#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, // non-shifted accumulator contribution
        3, // shifted accumulator contribution
    };
 
    static constexpr std::array<bool, 2> SUBRELATION_LINEARLY_INDEPENDENT = { false, false };
 
    template <typename AllEntities> inline static bool skip(const AllEntities& in)
    {
        return (in.batched_unshifted_accumulator.is_zero() && in.batched_shifted_accumulator.is_zero()) ||
               (in.eq_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 batched_unshifted_acc = Accumulator(in.batched_unshifted_accumulator);
        auto eq_acc = Accumulator(in.eq_accumulator);
        auto batched_shifted_acc = Accumulator(in.batched_shifted_accumulator);
 
        std::get<0>(evals) += (batched_unshifted_acc * eq_acc);
        std::get<1>(evals) += (batched_shifted_acc * eq_acc);
    };
};
template <typename FF_> class MultilinearBatchingInstanceRelationImpl {
  public:
    using FF = FF_;
 
    static constexpr std::array<size_t, 2> SUBRELATION_PARTIAL_LENGTHS{
        3, // non-shifted instance contribution
        3, // shifted instance contribution
    };
 
    static constexpr std::array<bool, 2> SUBRELATION_LINEARLY_INDEPENDENT = { false, false };
 
    template <typename AllEntities> static bool skip(const AllEntities& in)
    {
        return (in.batched_unshifted_accumulator.is_zero() && in.batched_unshifted_instance.is_zero() &&
                in.batched_shifted_accumulator.is_zero() && in.batched_shifted_instance.is_zero()) ||
               (in.eq_accumulator.is_zero() && in.eq_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 batched_unshifted_inst = Accumulator(in.batched_unshifted_instance);
        auto eq_inst = Accumulator(in.eq_instance);
        auto batched_shifted_inst = Accumulator(in.batched_shifted_instance);
 
        std::get<0>(evals) += (batched_unshifted_inst * eq_inst);
        std::get<1>(evals) += (batched_shifted_inst * eq_inst);
    };
};
 
template <typename FF>
using MultilinearBatchingInstanceRelation = Relation<MultilinearBatchingInstanceRelationImpl<FF>>;
template <typename FF>
using MultilinearBatchingAccumulatorRelation = Relation<MultilinearBatchingAccumulatorRelationImpl<FF>>;
} // namespace bb