relation_types.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/ecc/curves/bn254/fr.hpp"
#include "nested_containers.hpp"
#include <algorithm>
 
template <typename T>
concept IsField = std::same_as<T, bb::fr> /* || std::same_as<T, grumpkin::fr> */;
 
namespace bb {
 
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 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