relation_types.hpp

#pragma once
#include "barretenberg/ecc/curves/bn254/fr.hpp"
#include "nested_containers.hpp"
#include <algorithm>
 
template <typename T>
concept IsField = std::same_as<T, barretenberg::fr> /* || std::same_as<T, grumpkin::fr> */;
 
namespace proof_system {
 
template <typename Params, typename View>
using GetParameterView = std::conditional_t<IsField<typename Params::DataType>, typename Params::DataType, View>;
 
template <typename T, size_t subrelation_idx>
concept HasSubrelationLinearlyIndependentMember = requires(T) {
                                                      {
                                                          std::get<subrelation_idx>(T::SUBRELATION_LINEARLY_INDEPENDENT)
                                                          } -> std::convertible_to<bool>;
                                                  };
 
template <typename T>
concept HasParameterLengthAdjustmentsMember = requires { T::TOTAL_LENGTH_ADJUSTMENTS; };
 
template <typename Relation, size_t subrelation_index> constexpr bool subrelation_is_linearly_independent()
{
    if constexpr (HasSubrelationLinearlyIndependentMember<Relation, subrelation_index>) {
        return std::get<subrelation_index>(Relation::SUBRELATION_LINEARLY_INDEPENDENT);
    } else {
        return true;
    }
}
 
template <typename RelationImpl>
consteval std::array<size_t, RelationImpl::SUBRELATION_PARTIAL_LENGTHS.size()> compute_total_subrelation_lengths()
{
    if constexpr (HasParameterLengthAdjustmentsMember<RelationImpl>) {
        constexpr size_t NUM_SUBRELATIONS = RelationImpl::SUBRELATION_PARTIAL_LENGTHS.size();
        std::array<size_t, NUM_SUBRELATIONS> result;
        for (size_t idx = 0; idx < NUM_SUBRELATIONS; idx++) {
            result[idx] = RelationImpl::SUBRELATION_PARTIAL_LENGTHS[idx] + RelationImpl::TOTAL_LENGTH_ADJUSTMENTS[idx];
        }
        return result;
    } else {
        return RelationImpl::SUBRELATION_PARTIAL_LENGTHS;
    }
};
 
template <size_t NUM_INSTANCES, size_t NUM_SUBRELATIONS>
consteval std::array<size_t, NUM_SUBRELATIONS> compute_composed_subrelation_partial_lengths(
    std::array<size_t, NUM_SUBRELATIONS> SUBRELATION_PARTIAL_LENGTHS)
{
    std::transform(SUBRELATION_PARTIAL_LENGTHS.begin(),
                   SUBRELATION_PARTIAL_LENGTHS.end(),
                   SUBRELATION_PARTIAL_LENGTHS.begin(),
                   [](const size_t x) { return (x - 1) * (NUM_INSTANCES - 1) + 1; });
    return SUBRELATION_PARTIAL_LENGTHS;
};
 
template <typename RelationImpl> class Relation : public RelationImpl {
  public:
    using FF = typename RelationImpl::FF;
 
    static constexpr std::array<size_t, RelationImpl::SUBRELATION_PARTIAL_LENGTHS.size()> SUBRELATION_TOTAL_LENGTHS =
        compute_total_subrelation_lengths<RelationImpl>();
 
    static constexpr size_t RELATION_LENGTH = *std::max_element(RelationImpl::SUBRELATION_PARTIAL_LENGTHS.begin(),
                                                                RelationImpl::SUBRELATION_PARTIAL_LENGTHS.end());
 
    static constexpr size_t TOTAL_RELATION_LENGTH =
        *std::max_element(SUBRELATION_TOTAL_LENGTHS.begin(), SUBRELATION_TOTAL_LENGTHS.end());
 
    template <size_t NUM_INSTANCES>
    using ProtogalaxyTupleOfUnivariatesOverSubrelations =
        TupleOfUnivariates<FF, compute_composed_subrelation_partial_lengths<NUM_INSTANCES>(SUBRELATION_TOTAL_LENGTHS)>;
    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 proof_system