mock_witness_generator.hpp

Go to the documentation of this file.

#pragma once
 
#include "barretenberg/commitment_schemes/commitment_key.hpp"
#include "barretenberg/commitment_schemes/gemini/gemini.hpp"
#include "barretenberg/commitment_schemes/shplonk/shplemini.hpp"
#include "barretenberg/commitment_schemes/utils/test_utils.hpp"
#include "barretenberg/ecc/curves/bn254/bn254.hpp"
#include "barretenberg/polynomials/polynomial.hpp"
#include "barretenberg/transcript/transcript.hpp"
 
namespace bb {
template <typename Curve> struct MockClaimGenerator {
  public:
    using CommitmentKey = bb::CommitmentKey<Curve>;
    using Fr = typename Curve::ScalarField;
    using Commitment = typename Curve::AffineElement;
    using Polynomial = bb::Polynomial<Fr>;
    using PolynomialBatcher = bb::GeminiProver_<Curve>::PolynomialBatcher;
    using ClaimBatcher = ClaimBatcher_<Curve>;
    using ClaimBatch = ClaimBatcher::Batch;
 
    CommitmentKey ck;
 
    struct ClaimData {
        std::vector<Polynomial> polys;
        std::vector<Commitment> commitments;
        std::vector<Fr> evals;
    };
 
    ClaimData unshifted;
    ClaimData to_be_shifted;
 
    std::vector<Fr> const_size_mle_opening_point;
 
    PolynomialBatcher polynomial_batcher;
    ClaimBatcher claim_batcher;
 
    // Containers for mock Sumcheck data
    std::vector<bb::Polynomial<Fr>> round_univariates;
    std::vector<Commitment> sumcheck_commitments;
    std::vector<std::array<Fr, 3>> sumcheck_evaluations;
 
    MockClaimGenerator(const size_t poly_size,
                       const size_t num_polynomials,
                       const size_t num_to_be_shifted,
                       const std::vector<Fr>& mle_opening_point,
                       const CommitmentKey& commitment_key)
 
        : ck(commitment_key) // Initialize the commitment key
        , polynomial_batcher(poly_size)
 
    {
        size_t log_size = numeric::get_msb(poly_size);
        // If the size of the opening point is bigger than the log of the poly size, we assume that the prover is
        // extending all of its polynomials by zero outside of the hypercube of size 2^{log_size}.
        bool has_virtual_rounds = (mle_opening_point.size() > log_size);
 
        std::span<const Fr> challenge;
 
        if (has_virtual_rounds) {
            // The evaluation on the full domain can be obtain by scaling by extension-by-zero factor `ebz_factor`
            // computed below.
            challenge = std::span<const Fr>(mle_opening_point).subspan(0, log_size);
        } else {
            challenge = std::span<const Fr>(mle_opening_point);
        }
 
        BB_ASSERT_GTE(num_polynomials, num_to_be_shifted);
        const size_t num_not_to_be_shifted = num_polynomials - num_to_be_shifted;
 
        Fr ebz_factor = 1;
 
        for (size_t idx = log_size; idx < mle_opening_point.size(); idx++) {
            ebz_factor *= (Fr(1) - mle_opening_point[idx]);
        }
 
        // Construct claim data for polynomials that are NOT to be shifted
        for (size_t idx = 0; idx < num_not_to_be_shifted; idx++) {
            Polynomial poly = Polynomial::random(poly_size);
            unshifted.commitments.push_back(ck.commit(poly));
            unshifted.evals.push_back(poly.evaluate_mle(challenge) * ebz_factor);
            unshifted.polys.push_back(std::move(poly));
        }
 
        // Construct claim data for polynomials that are to-be-shifted
        for (size_t idx = 0; idx < num_to_be_shifted; idx++) {
            Polynomial poly = Polynomial::random(poly_size, /*shiftable*/ 1);
            Commitment commitment = ck.commit(poly);
            to_be_shifted.commitments.push_back(commitment);
            to_be_shifted.evals.push_back(poly.shifted().evaluate_mle(challenge) * ebz_factor);
            to_be_shifted.polys.push_back(poly.share());
            // Populate the unshifted counterpart in the unshifted claims
            unshifted.commitments.push_back(commitment);
            unshifted.evals.push_back(poly.evaluate_mle(challenge) * ebz_factor);
            unshifted.polys.push_back(std::move(poly));
        }
 
        polynomial_batcher.set_unshifted(RefVector(unshifted.polys));
        polynomial_batcher.set_to_be_shifted_by_one(RefVector(to_be_shifted.polys));
 
        claim_batcher =
            ClaimBatcher{ .unshifted = ClaimBatch{ RefVector(unshifted.commitments), RefVector(unshifted.evals) },
                          .shifted =
                              ClaimBatch{ RefVector(to_be_shifted.commitments), RefVector(to_be_shifted.evals) } };
    }
 
    // Generate zero polynomials to test edge cases in PCS
    MockClaimGenerator(const size_t n, const size_t num_zero_polynomials)
        : polynomial_batcher(n)
    {
        for (size_t idx = 0; idx < num_zero_polynomials; idx++) {
            unshifted.polys.emplace_back(n);
            unshifted.commitments.push_back(Commitment::infinity());
            unshifted.evals.push_back(Fr(0));
        }
 
        polynomial_batcher.set_unshifted(RefVector(unshifted.polys));
 
        claim_batcher =
            ClaimBatcher{ .unshifted = ClaimBatch{ RefVector(unshifted.commitments), RefVector(unshifted.evals) } };
    }
 
    // Generates mock claims by using the custom polynomials provided as input instead of random polynomials. Used for
    // the high degree attack tests.
    MockClaimGenerator(const size_t poly_size,
                       const std::vector<Polynomial> custom_unshifted,
                       const std::vector<Fr>& custom_unshifted_evals,
                       const CommitmentKey& commitment_key)
 
        : ck(commitment_key)
        , polynomial_batcher(poly_size)
    {
 
        //  ---------- Unshifted ----------
        for (size_t i = 0; i < custom_unshifted.size(); ++i) {
            auto& p = custom_unshifted[i];
            unshifted.commitments.push_back(ck.commit(p));
            unshifted.evals.push_back(custom_unshifted_evals[i]);
            unshifted.polys.push_back(std::move(p));
        }
 
        polynomial_batcher.set_unshifted(RefVector(unshifted.polys));
 
        claim_batcher =
            ClaimBatcher{ .unshifted = ClaimBatch{ RefVector(unshifted.commitments), RefVector(unshifted.evals) } };
    }
 
    template <typename Flavor>
    void compute_sumcheck_opening_data(const size_t log_n,
                                       const size_t sumcheck_univariate_length,
                                       std::vector<Fr>& challenge,
                                       const CommitmentKey& ck)
    {
        // Generate valid sumcheck polynomials of given length
        auto mock_sumcheck_polynomials = ZKSumcheckData<Flavor>(log_n, sumcheck_univariate_length);
 
        for (size_t idx = 0; idx < log_n; idx++) {
            bb::Polynomial<Fr> round_univariate = mock_sumcheck_polynomials.libra_univariates[idx];
 
            round_univariate.at(0) += mock_sumcheck_polynomials.libra_running_sum;
 
            sumcheck_commitments.push_back(ck.commit(round_univariate));
 
            sumcheck_evaluations.push_back({ round_univariate.at(0),
                                             round_univariate.evaluate(Fr(1)),
                                             round_univariate.evaluate(challenge[idx]) });
 
            mock_sumcheck_polynomials.update_zk_sumcheck_data(challenge[idx], idx);
            round_univariates.push_back(round_univariate);
        }
    }
};
 
} // namespace bb