relation_types.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/ecc/curves/bn254/fr.hpp"
#include "nested_containers.hpp"
#include <algorithm>
 
namespace bb {
 
template <typename Accumulator>
concept IsProverAccumulator = requires { Accumulator::LENGTH; };
 
template <typename T>
concept HasSubrelationLinearlyIndependentMember = requires(T) {
    { std::get<0>(T::SUBRELATION_LINEARLY_INDEPENDENT) } -> std::convertible_to<bool>;
};
 
template <typename Relation, size_t subrelation_index> constexpr bool subrelation_is_linearly_independent()
{
    if constexpr (HasSubrelationLinearlyIndependentMember<Relation>) {
        return std::get<subrelation_index>(Relation::SUBRELATION_LINEARLY_INDEPENDENT);
    } else {
        return true;
    }
}
 
template <typename Relation, typename AllEntities>
concept isSkippable = requires(const AllEntities& input) {
    { Relation::skip(input) } -> std::same_as<bool>;
};
 
template <typename Flavor, typename ProverPolynomialsOrPartiallyEvaluatedMultivariates, typename EdgeType>
concept isRowSkippable =
    requires(const ProverPolynomialsOrPartiallyEvaluatedMultivariates& input, const EdgeType edge_idx) {
        { Flavor::skip_entire_row(input, edge_idx) } -> std::same_as<bool>;
    };
 
template <typename Relation>
concept IsOffsetOnlyRelation = requires {
    { Relation::IS_OFFSET_ONLY } -> std::convertible_to<bool>;
    requires Relation::IS_OFFSET_ONLY;
};
 
template <typename RelationImpl> class Relation : public RelationImpl {
  public:
    using FF = typename RelationImpl::FF;
 
    static constexpr size_t RELATION_LENGTH = *std::max_element(RelationImpl::SUBRELATION_PARTIAL_LENGTHS.begin(),
                                                                RelationImpl::SUBRELATION_PARTIAL_LENGTHS.end());
 
    using SumcheckTupleOfUnivariatesOverSubrelations =
        TupleOfUnivariates<FF, RelationImpl::SUBRELATION_PARTIAL_LENGTHS>;
 
    using SumcheckArrayOfValuesOverSubrelations = ArrayOfValues<FF, RelationImpl::SUBRELATION_PARTIAL_LENGTHS>;
 
    // These are commonly needed, most importantly, for explicitly instantiating
    // compute_foo_numerator/denomintor.
    using UnivariateAccumulator0 = std::tuple_element_t<0, SumcheckTupleOfUnivariatesOverSubrelations>;
    using ValueAccumulator0 = std::tuple_element_t<0, SumcheckArrayOfValuesOverSubrelations>;
};
} // namespace bb