sumcheck_test_flavor.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/commitment_schemes/kzg/kzg.hpp"
#include "barretenberg/flavor/flavor.hpp"
#include "barretenberg/flavor/flavor_macros.hpp"
#include "barretenberg/polynomials/univariate.hpp"
#include "barretenberg/relations/relation_types.hpp"
#include "barretenberg/relations/ultra_arithmetic_relation.hpp"
#include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
#include "barretenberg/transcript/transcript.hpp"
 
namespace bb {
 
template <typename FF_> class DependentTestRelationImpl {
  public:
    using FF = FF_;
 
    static constexpr std::array<size_t, 1> SUBRELATION_PARTIAL_LENGTHS{
        2 // degree 1: q_test * w_test_1
    };
 
    static constexpr std::array<bool, 1> SUBRELATION_LINEARLY_INDEPENDENT{
        false // This subrelation is NOT linearly independent (should NOT be scaled)
    };
 
    template <typename AllEntities> static bool skip(const AllEntities& in) { return in.q_test.is_zero(); }
 
    template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
    static void accumulate(ContainerOverSubrelations& evals,
                           const AllEntities& in,
                           const Parameters& /*unused*/,
                           const FF& /*scaling_factor*/)
    {
        using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
        // Note: NO scaling_factor used here - this is linearly dependent!
        auto tmp = in.w_test_1 * in.q_test;
        std::get<0>(evals) += Accumulator(tmp);
    }
};
 
template <typename FF> using DependentTestRelation = Relation<DependentTestRelationImpl<FF>>;
 
} // namespace bb
 
namespace bb {
 
template <typename CurveType = curve::BN254, bool HasZK_ = false, bool UseShortMonomials_ = true>
class SumcheckTestFlavor_ {
  public:
    using CircuitBuilder = UltraCircuitBuilder;
    using Curve = CurveType;
    using FF = typename Curve::ScalarField;
    using GroupElement = typename Curve::Element;
    using Commitment = typename Curve::AffineElement;
    using PCS = KZG<Curve>;
    using Polynomial = bb::Polynomial<FF>;
    using CommitmentKey = bb::CommitmentKey<Curve>;
    using VerifierCommitmentKey = bb::VerifierCommitmentKey<Curve>;
    using Transcript = NativeTranscript;
 
    // Configuration constants from template parameters
    static constexpr bool HasZK = HasZK_;
    static constexpr bool USE_SHORT_MONOMIALS = UseShortMonomials_;
    static constexpr bool USE_PADDING = false;
    static constexpr size_t NUM_WIRES = 4;
 
    // Entity counts:
    // Precomputed: q_m, q_l, q_r, q_o, q_4, q_c, q_arith + q_test = 8
    // Witness: w_l, w_r, w_o, w_4 + w_test_1, w_test_2 = 6
    // Shifted: w_l_shift, w_4_shift = 2
    // Note: No gemini_masking_poly - that's a PCS concept, not sumcheck
    static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 8;
    static constexpr size_t NUM_WITNESS_ENTITIES = 6;
    static constexpr size_t NUM_SHIFTED_ENTITIES = 2;
    static constexpr size_t NUM_ALL_ENTITIES = NUM_PRECOMPUTED_ENTITIES + NUM_WITNESS_ENTITIES + NUM_SHIFTED_ENTITIES;
 
    // Two relations: Arithmetic (linearly independent) + DependentTest (linearly dependent)
    // Tests can activate either or both via selectors:
    // - q_arith = 1 : activate arithmetic relation (linearly independent, WILL be scaled)
    // - q_test = 1 : activate dependent test relation (linearly dependent, will NOT be scaled)
    template <typename FF_> using Relations_ = std::tuple<ArithmeticRelation<FF_>, DependentTestRelation<FF_>>;
    using Relations = Relations_<FF>;
 
    static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length<Relations>();
    // For ZK flavors, BATCHED_RELATION_PARTIAL_LENGTH is incremented by 1 for the libra masking univariates
    // For BN254 with ZK, this must match Curve::LIBRA_UNIVARIATES_LENGTH (9)
    // Note: MAX_PARTIAL_RELATION_LENGTH = 6 (from ArithmeticRelation's [6,5])
    // Non-ZK: 6 + 1 = 7
    // ZK: 6 + 3 = 9 (matches BN254::LIBRA_UNIVARIATES_LENGTH)
    static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH = MAX_PARTIAL_RELATION_LENGTH + (HasZK ? 3 : 1);
    static constexpr size_t NUM_SUBRELATIONS = compute_number_of_subrelations<Relations>();
    static constexpr size_t NUM_RELATIONS = std::tuple_size_v<Relations>;
    using SubrelationSeparator = FF;
 
    static constexpr bool has_zero_row = false;
 
    template <typename DataType> class PrecomputedEntities {
      public:
        DEFINE_FLAVOR_MEMBERS(DataType,
                              q_m,     // Multiplication selector (arithmetic)
                              q_l,     // Left wire selector (arithmetic)
                              q_r,     // Right wire selector (arithmetic)
                              q_o,     // Output wire selector (arithmetic)
                              q_4,     // Fourth wire selector (arithmetic)
                              q_c,     // Constant selector (arithmetic)
                              q_arith, // Arithmetic gate enable (linearly independent, WILL be scaled)
                              q_test)  // Test relation enable (linearly dependent, will NOT be scaled)
    };
 
    template <typename DataType> class WitnessEntities {
      public:
        DEFINE_FLAVOR_MEMBERS(DataType,
                              w_l,      // Left wire (arithmetic)
                              w_r,      // Right wire (arithmetic)
                              w_o,      // Output wire (arithmetic)
                              w_4,      // Fourth wire (arithmetic)
                              w_test_1, // Test wire 1 (dependent test relation)
                              w_test_2) // Test wire 2 (dependent test relation, currently unused)
    };
 
    template <typename DataType> class ShiftedEntities {
      public:
        DEFINE_FLAVOR_MEMBERS(DataType,
                              w_l_shift, // w_l shifted by 1
                              w_4_shift) // w_4 shifted by 1
    };
 
    template <typename DataType>
    class AllEntities : public PrecomputedEntities<DataType>,
                        public WitnessEntities<DataType>,
                        public ShiftedEntities<DataType> {
      public:
        DEFINE_COMPOUND_GET_ALL(PrecomputedEntities<DataType>, WitnessEntities<DataType>, ShiftedEntities<DataType>)
 
        auto get_precomputed() { return PrecomputedEntities<DataType>::get_all(); }
        auto get_witness() { return WitnessEntities<DataType>::get_all(); }
        auto get_witness() const { return WitnessEntities<DataType>::get_all(); }
        auto get_shifted() { return ShiftedEntities<DataType>::get_all(); }
    };
 
    class ProverPolynomials : public AllEntities<Polynomial> {
      public:
        ProverPolynomials() = default;
        ProverPolynomials(size_t circuit_size)
        {
            for (auto& poly : this->get_precomputed()) {
                poly = Polynomial(circuit_size);
            }
            for (auto& poly : this->get_witness()) {
                poly = Polynomial(circuit_size);
            }
            for (auto& poly : this->get_shifted()) {
                poly = Polynomial(circuit_size);
            }
        }
 
        [[nodiscard]] size_t get_polynomial_size() const { return this->w_l.size(); }
 
        auto get_to_be_shifted() { return RefArray{ this->w_l, this->w_4 }; }
 
        void set_shifted()
        {
            for (auto [shifted, to_be_shifted] : zip_view(this->get_shifted(), this->get_to_be_shifted())) {
                shifted = to_be_shifted.shifted();
            }
        }
    };
 
    template <size_t LENGTH> using ProverUnivariates = AllEntities<bb::Univariate<FF, LENGTH>>;
 
    using ExtendedEdges = ProverUnivariates<MAX_PARTIAL_RELATION_LENGTH>;
 
    class AllValues : public AllEntities<FF> {
      public:
        using Base = AllEntities<FF>;
        using Base::Base;
    };
 
    class PartiallyEvaluatedMultivariates : public AllEntities<Polynomial> {
      public:
        PartiallyEvaluatedMultivariates() = default;
        PartiallyEvaluatedMultivariates(const ProverPolynomials& full_polynomials, size_t circuit_size)
        {
            for (auto [poly, full_poly] : zip_view(this->get_all(), full_polynomials.get_all())) {
                size_t desired_size = (full_poly.end_index() / 2) + (full_poly.end_index() % 2);
                poly = Polynomial(desired_size, circuit_size / 2);
            }
        }
    };
};
 
// ================================================================================================
// Convenient type aliases for common test configurations
// ================================================================================================
// Note: All flavors include both relations (arithmetic + test).
// Tests can choose which to activate via selectors (q_arith = 1 or q_test = 1).
 
using SumcheckTestFlavor = SumcheckTestFlavor_<curve::BN254, false, true>;
 
using SumcheckTestFlavorZK = SumcheckTestFlavor_<curve::BN254, true, true>;
 
using SumcheckTestFlavorFullBary = SumcheckTestFlavor_<curve::BN254, false, false>;
 
using SumcheckTestFlavorGrumpkinZK = SumcheckTestFlavor_<curve::Grumpkin, true, true>;
 
using SumcheckTestFlavorZKFullBary = SumcheckTestFlavor_<curve::BN254, true, false>;
 
} // namespace bb