flavor.hpp

Go to the documentation of this file.

 
#pragma once
#include "barretenberg/common/ref_vector.hpp"
#include "barretenberg/common/std_array.hpp"
#include "barretenberg/common/std_vector.hpp"
#include "barretenberg/common/zip_view.hpp"
#include "barretenberg/polynomials/barycentric.hpp"
#include "barretenberg/polynomials/evaluation_domain.hpp"
#include "barretenberg/polynomials/univariate.hpp"
#include "barretenberg/proof_system/types/circuit_type.hpp"
#include <array>
#include <concepts>
#include <vector>
 
namespace proof_system::honk::flavor {
 
class PrecomputedEntitiesBase {
  public:
    size_t circuit_size;
    size_t log_circuit_size;
    size_t num_public_inputs;
    CircuitType circuit_type; // TODO(#392)
};
 
template <typename PrecomputedPolynomials, typename WitnessPolynomials>
class ProvingKey_ : public PrecomputedPolynomials, public WitnessPolynomials {
  public:
    using Polynomial = typename PrecomputedPolynomials::DataType;
    using FF = typename Polynomial::FF;
 
    bool contains_recursive_proof;
    std::vector<uint32_t> recursive_proof_public_input_indices;
    barretenberg::EvaluationDomain<FF> evaluation_domain;
 
    std::vector<std::string> get_labels() const
    {
        return concatenate(PrecomputedPolynomials::get_labels(), WitnessPolynomials::get_labels());
    }
    // This order matters! must match get_unshifted in entity classes
    RefVector<Polynomial> get_all() { return concatenate(get_precomputed_polynomials(), get_witness_polynomials()); }
    RefVector<Polynomial> get_witness_polynomials() { return WitnessPolynomials::get_all(); }
    RefVector<Polynomial> get_precomputed_polynomials() { return PrecomputedPolynomials::get_all(); }
    ProvingKey_() = default;
    ProvingKey_(const size_t circuit_size, const size_t num_public_inputs)
    {
        this->evaluation_domain = barretenberg::EvaluationDomain<FF>(circuit_size, circuit_size);
        PrecomputedPolynomials::circuit_size = circuit_size;
        this->log_circuit_size = numeric::get_msb(circuit_size);
        this->num_public_inputs = num_public_inputs;
        // Allocate memory for precomputed polynomials
        for (auto& poly : PrecomputedPolynomials::get_all()) {
            poly = Polynomial(circuit_size);
        }
        // Allocate memory for witness polynomials
        for (auto& poly : WitnessPolynomials::get_all()) {
            poly = Polynomial(circuit_size);
        }
    };
};
 
template <typename PrecomputedCommitments> class VerificationKey_ : public PrecomputedCommitments {
  public:
    VerificationKey_() = default;
    VerificationKey_(const size_t circuit_size, const size_t num_public_inputs)
    {
        this->circuit_size = circuit_size;
        this->log_circuit_size = numeric::get_msb(circuit_size);
        this->num_public_inputs = num_public_inputs;
    };
};
 
// Because of how Gemini is written, is importat to put the polynomials out in this order.
auto get_unshifted_then_shifted(const auto& all_entities)
{
    return concatenate(all_entities.get_unshifted(), all_entities.get_shifted());
};
 
template <typename Tuple, std::size_t Index = 0> static constexpr size_t compute_max_partial_relation_length()
{
    if constexpr (Index >= std::tuple_size<Tuple>::value) {
        return 0; // Return 0 when reach end of the tuple
    } else {
        constexpr size_t current_length = std::tuple_element<Index, Tuple>::type::RELATION_LENGTH;
        constexpr size_t next_length = compute_max_partial_relation_length<Tuple, Index + 1>();
        return (current_length > next_length) ? current_length : next_length;
    }
}
 
template <typename Tuple, std::size_t Index = 0> static constexpr size_t compute_max_total_relation_length()
{
    if constexpr (Index >= std::tuple_size<Tuple>::value) {
        return 0; // Return 0 when reach end of the tuple
    } else {
        constexpr size_t current_length = std::tuple_element<Index, Tuple>::type::TOTAL_RELATION_LENGTH;
        constexpr size_t next_length = compute_max_total_relation_length<Tuple, Index + 1>();
        return (current_length > next_length) ? current_length : next_length;
    }
}
 
template <typename Tuple, std::size_t Index = 0> static constexpr size_t compute_number_of_subrelations()
{
    if constexpr (Index >= std::tuple_size<Tuple>::value) {
        return 0;
    } else {
        constexpr size_t subrelations_in_relation =
            std::tuple_element_t<Index, Tuple>::SUBRELATION_PARTIAL_LENGTHS.size();
        return subrelations_in_relation + compute_number_of_subrelations<Tuple, Index + 1>();
    }
}
template <typename Tuple, size_t NUM_INSTANCES, size_t Index = 0>
static constexpr auto create_protogalaxy_tuple_of_tuples_of_univariates()
{
    if constexpr (Index >= std::tuple_size<Tuple>::value) {
        return std::tuple<>{}; // Return empty when reach end of the tuple
    } else {
        using UnivariateTuple =
            typename std::tuple_element_t<Index,
                                          Tuple>::template ProtogalaxyTupleOfUnivariatesOverSubrelations<NUM_INSTANCES>;
        return std::tuple_cat(std::tuple<UnivariateTuple>{},
                              create_protogalaxy_tuple_of_tuples_of_univariates<Tuple, NUM_INSTANCES, Index + 1>());
    }
}
 
template <typename Tuple, std::size_t Index = 0> static constexpr auto create_sumcheck_tuple_of_tuples_of_univariates()
{
    if constexpr (Index >= std::tuple_size<Tuple>::value) {
        return std::tuple<>{}; // Return empty when reach end of the tuple
    } else {
        using UnivariateTuple = typename std::tuple_element_t<Index, Tuple>::SumcheckTupleOfUnivariatesOverSubrelations;
        return std::tuple_cat(std::tuple<UnivariateTuple>{},
                              create_sumcheck_tuple_of_tuples_of_univariates<Tuple, Index + 1>());
    }
}
 
template <typename Tuple, std::size_t Index = 0> static constexpr auto create_tuple_of_arrays_of_values()
{
    if constexpr (Index >= std::tuple_size<Tuple>::value) {
        return std::tuple<>{}; // Return empty when reach end of the tuple
    } else {
        using Values = typename std::tuple_element_t<Index, Tuple>::SumcheckArrayOfValuesOverSubrelations;
        return std::tuple_cat(std::tuple<Values>{}, create_tuple_of_arrays_of_values<Tuple, Index + 1>());
    }
}
 
} // namespace proof_system::honk::flavor
 
// Forward declare honk flavors
namespace proof_system::honk::flavor {
class Ultra;
class ECCVM;
class GoblinUltra;
template <typename BuilderType> class UltraRecursive_;
template <typename BuilderType> class GoblinUltraRecursive_;
} // namespace proof_system::honk::flavor
 
// Forward declare plonk flavors
namespace proof_system::plonk::flavor {
class Standard;
class Ultra;
} // namespace proof_system::plonk::flavor
 
// Establish concepts for testing flavor attributes
namespace proof_system {
// clang-format off
 
template <typename T>
concept IsPlonkFlavor = IsAnyOf<T, plonk::flavor::Standard, plonk::flavor::Ultra>;
 
template <typename T> 
concept IsHonkFlavor = IsAnyOf<T, honk::flavor::Ultra, honk::flavor::GoblinUltra>;
 
template <typename T> 
concept IsUltraFlavor = IsAnyOf<T, honk::flavor::Ultra, honk::flavor::GoblinUltra>;
 
template <typename T> 
concept IsGoblinFlavor = IsAnyOf<T, honk::flavor::GoblinUltra,
                                    honk::flavor::GoblinUltraRecursive_<UltraCircuitBuilder>, 
                                    honk::flavor::GoblinUltraRecursive_<GoblinUltraCircuitBuilder>>;
 
template <typename T> 
concept IsRecursiveFlavor = IsAnyOf<T, honk::flavor::UltraRecursive_<UltraCircuitBuilder>, 
                                       honk::flavor::UltraRecursive_<GoblinUltraCircuitBuilder>, 
                                       honk::flavor::GoblinUltraRecursive_<UltraCircuitBuilder>, 
                                       honk::flavor::GoblinUltraRecursive_<GoblinUltraCircuitBuilder>>;
 
template <typename T> concept IsGrumpkinFlavor = IsAnyOf<T, honk::flavor::ECCVM>;
 
template <typename T> concept UltraFlavor = IsAnyOf<T, honk::flavor::Ultra, honk::flavor::GoblinUltra>;
 
template <typename T> concept ECCVMFlavor = IsAnyOf<T, honk::flavor::ECCVM>;
 
template <typename Container, typename Element>
inline std::string flavor_get_label(Container&& container, const Element& element) {
    for (auto [label, data] : zip_view(container.get_labels(), container.get_all())) {
        if (&data == &element) {
            return label;
        }
    }
    return "(unknown label)";
}
 
// clang-format on
} // namespace proof_system