interaction_def.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "barretenberg/common/assert.hpp"
#include "barretenberg/vm2/tracegen/lib/interaction_builder.hpp"
#include "barretenberg/vm2/tracegen/lib/lookup_builder.hpp"
#include "barretenberg/vm2/tracegen/lib/lookup_into_bitwise.hpp"
#include "barretenberg/vm2/tracegen/lib/lookup_into_indexed_by_row.hpp"
#include "barretenberg/vm2/tracegen/lib/lookup_into_p_decomposition.hpp"
#include "barretenberg/vm2/tracegen/lib/multi_permutation_builder.hpp"
#include "barretenberg/vm2/tracegen/lib/permutation_builder.hpp"
#include "barretenberg/vm2/tracegen/lib/shared_index_cache.hpp"
#include "barretenberg/vm2/tracegen/lib/test_interaction_builder.hpp"
 
namespace bb::avm2::tracegen {
 
enum class InteractionType {
    LookupGeneric,
    LookupSequential,
    LookupIntoBitwise,
    LookupIntoIndexedByRow,
    LookupIntoPDecomposition,
    Permutation,
    MultiPermutation,
};
 
class InteractionDefinition {
  public:
    InteractionDefinition() = default;
 
    template <InteractionType type, typename... InteractionSettings> InteractionDefinition& add(auto&&... args)
    {
        std::string name = (std::string(InteractionSettings::NAME) + ...);
        auto [_, inserted] = interactions.emplace(
            name, get_interaction_factory<type, InteractionSettings...>(std::forward<decltype(args)>(args)...));
 
        // Safeguard detecting a collision in the interaction names (we do not use separators to have an injective
        // serialization).
        BB_ASSERT_DEBUG(inserted, "InteractionDefinition::add: collision in interaction name: " + name);
        return *this;
    }
 
    // Jobs for production (with shared index cache for efficient lookup index sharing).
    std::vector<std::unique_ptr<InteractionBuilderInterface>> get_all_jobs(SharedIndexCache& cache) const;
    // Stricter/more assertive jobs for testing.
    std::vector<std::unique_ptr<InteractionBuilderInterface>> get_all_test_jobs(SharedIndexCache& cache) const;
 
    std::unique_ptr<InteractionBuilderInterface> get_job(const std::string& interaction_name,
                                                         SharedIndexCache& cache) const;
    std::unique_ptr<InteractionBuilderInterface> get_test_job(const std::string& interaction_name,
                                                              SharedIndexCache& cache) const;
    template <typename InteractionSettings>
    std::unique_ptr<InteractionBuilderInterface> get_test_job(SharedIndexCache& cache) const
    {
        return get_test_job(std::string(InteractionSettings::NAME), cache);
    }
 
  private:
    // Factory takes (strict, cache) and returns the interaction builder.
    using Factory = std::function<std::unique_ptr<InteractionBuilderInterface>(bool strict, SharedIndexCache& cache)>;
    std::unordered_map<std::string, Factory> interactions;
 
    template <InteractionType type, typename... InteractionSettings>
    static Factory get_interaction_factory(auto&&... args)
    {
        if constexpr (type == InteractionType::LookupGeneric) {
            return [args...](bool, SharedIndexCache& cache) {
                // This class always checks.
                return std::make_unique<LookupIntoDynamicTableGeneric<InteractionSettings...>>(cache, args...);
            };
        } else if constexpr (type == InteractionType::LookupIntoBitwise) {
            return [args...](bool strict, SharedIndexCache&) {
                return strict ? std::make_unique<AddChecksToBuilder<LookupIntoBitwise<InteractionSettings...>>>(args...)
                              : std::make_unique<LookupIntoBitwise<InteractionSettings...>>(args...);
            };
        } else if constexpr (type == InteractionType::LookupIntoIndexedByRow) {
            return [args...](bool strict, SharedIndexCache&) {
                return strict ? std::make_unique<AddChecksToBuilder<LookupIntoIndexedByRow<InteractionSettings...>>>(
                                    args...)
                              : std::make_unique<LookupIntoIndexedByRow<InteractionSettings...>>(args...);
            };
        } else if constexpr (type == InteractionType::LookupIntoPDecomposition) {
            return [args...](bool strict, SharedIndexCache&) {
                return strict ? std::make_unique<AddChecksToBuilder<LookupIntoPDecomposition<InteractionSettings...>>>(
                                    args...)
                              : std::make_unique<LookupIntoPDecomposition<InteractionSettings...>>(args...);
            };
        } else if constexpr (type == InteractionType::LookupSequential) {
            return [args...](bool, SharedIndexCache&) {
                // This class always checks.
                return std::make_unique<LookupIntoDynamicTableSequential<InteractionSettings...>>(args...);
            };
        } else if constexpr (type == InteractionType::Permutation) {
            return [args...](bool strict, SharedIndexCache&) {
                return strict ? std::make_unique<CheckingPermutationBuilder<InteractionSettings...>>(args...)
                              : std::make_unique<PermutationBuilder<InteractionSettings...>>(args...);
            };
        } else if constexpr (type == InteractionType::MultiPermutation) {
            return [args...](bool, SharedIndexCache&) {
                return std::make_unique<MultiPermutationBuilder<InteractionSettings...>>(args...);
            };
        } else {
            throw std::runtime_error("Interaction type not supported: " + std::to_string(static_cast<int>(type)));
        }
    }
 
    const Factory& get_job_internal(const std::string& interaction_name) const;
};
 
} // namespace bb::avm2::tracegen